Uses of Class
org.jooq.Support

Packages that use Support

org.jooq
org.jooq.impl

Uses of Support in org.jooq

Methods in org.jooq with annotations of type Support

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	ConditionProvider.addConditions(Collection<Condition> conditions) Adds new conditions to the query, connecting them to existing conditions with Operator.AND
void	ConditionProvider.addConditions(Condition... conditions) Adds new conditions to the query, connecting them to existing conditions with Operator.AND
void	ConditionProvider.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, Condition... conditions) 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
void	SelectQuery.addGroupBy(Field<?>... fields) Adds grouping fields
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.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) 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	OrderProvider.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 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, 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) 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, 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, 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.addOrderBy(Collection<SortField<?>> fields) Adds ordering fields
void	OrderProvider.addOrderBy(Field<?>... fields) Adds ordering fields, ordering by the default sort order
void	OrderProvider.addOrderBy(int... fieldIndexes) Adds ordering fields Indexes start at 1 in SQL!
void	OrderProvider.addOrderBy(SortField<?>... fields) 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.
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 ...
Field<T>	Field.as(String alias) Create an alias for this field
Z	AliasProvider.as(String alias) Get an aliased QueryPart.
SortField<T>	Field.asc() Create an ascending sort field from this field
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).
Condition	Field.between(Field<T> minValue, Field<T> maxValue) 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 SQL: this between 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.
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.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.
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) 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.
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(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
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) 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.equal(Field<T> field) this = field
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	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.
<R extends TableRecord<R>> int	FactoryOperations.executeDelete(Table<R> table) Delete records from a table DELETE FROM [table]
<R extends TableRecord<R>,T> int	FactoryOperations.executeDelete(Table<R> table, Condition condition) Delete records from a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>> int	FactoryOperations.executeDeleteOne(Table<R> table) Delete one record in a table DELETE FROM [table]
<R extends TableRecord<R>,T> int	FactoryOperations.executeDeleteOne(Table<R> table, Condition condition) Delete one record in a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>> int	FactoryOperations.executeInsert(Table<R> table, R record) Insert one record INSERT INTO [table] ...
<R extends TableRecord<R>> int	FactoryOperations.executeUpdate(Table<R> table, R record) Update a table UPDATE [table] SET [modified values in record]
<R extends TableRecord<R>,T> int	FactoryOperations.executeUpdate(Table<R> table, R record, Condition condition) Update a table UPDATE [table] SET [modified values in record] WHERE [condition]
<R extends TableRecord<R>> int	FactoryOperations.executeUpdateOne(Table<R> table, R record) Update one record in a table UPDATE [table] SET [modified values in record]
<R extends TableRecord<R>,T> int	FactoryOperations.executeUpdateOne(Table<R> table, R record, Condition condition) Update one record in a table UPDATE [table] SET [modified values in record] WHERE [condition]
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.
<R extends Record> Result<R>	FactoryOperations.fetch(Table<R> table) Execute and return all records for SELECT * FROM [table]
<R extends Record> Result<R>	FactoryOperations.fetch(Table<R> table, Condition condition) Execute and return all records for SELECT * FROM [table] WHERE [condition]
<R extends Record> R	FactoryOperations.fetchAny(Table<R> table) Execute and return zero or one record for SELECT * FROM [table] LIMIT 1
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.
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.
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.
<R extends Record> R	FactoryOperations.fetchOne(Table<R> table) Execute and return zero or one record for SELECT * FROM [table]
<R extends Record> R	FactoryOperations.fetchOne(Table<R> table, Condition condition) Execute and return zero or one record for SELECT * FROM [table] WHERE [condition]
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(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(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
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
SelectHavingStep	SelectGroupByStep.groupBy(Field<?>... fields) Add a GROUP BY clause to the query
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.
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	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	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.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.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(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)
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.
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.
TableOnStep	Table.leftOuterJoin(String sql) LEFT OUTER JOIN a table to this table.
SelectOnStep	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.
TableOnStep	Table.leftOuterJoin(String sql, Object... bindings) LEFT OUTER JOIN a table to this table.
SelectOnStep	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...)
TableOnStep	Table.leftOuterJoin(TableLike<?> table) LEFT OUTER JOIN a table to this table.
SelectOnStep	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'
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.
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 merge statement.
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(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(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(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.
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
Condition	Field.notBetween(Field<T> minValue, Field<T> maxValue) 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 SQL: this not between minValue and maxValue
Condition	Field.notEqual(Field<T> field) this !
Condition	Field.notEqual(Select<?> query) this !
Condition	Field.notEqual(T value) this !
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	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	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> value) Create a condition to pattern-check this field against a value SQL: this not like value
Condition	Field.notLike(Field<String> value, char escape) Create a condition to pattern-check this field against a value SQL: this not like value 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'
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
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.
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.
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.
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
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>	AggregateFunction.over() Turn this aggregate function into a window function, for example MAX(ID) OVER (PARTITION BY 1) Window functions are supported in DB2, Postgres, Oracle, SQL Server and Sybase.
WindowOrderByStep<T>	WindowPartitionByStep.partitionBy(Field<?>... fields) Add a PARTITION BY clause to the window functions.
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.
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.
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
TableOnStep	Table.rightOuterJoin(String sql) RIGHT OUTER JOIN a table to this table.
SelectOnStep	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.
TableOnStep	Table.rightOuterJoin(String sql, Object... bindings) RIGHT OUTER JOIN a table to this table.
SelectOnStep	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...)
TableOnStep	Table.rightOuterJoin(TableLike<?> table) RIGHT OUTER JOIN a table to this table.
SelectOnStep	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.
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) .execute();
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) .execute();
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) .execute();
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	LockProvider.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.setForUpdate(boolean forUpdate) Sets the "FOR UPDATE" flag onto the query This has been observed to be supported by any of these dialects:	void	LockProvider.setForUpdateNoWait() Some RDBMS allow for specifying the locking mode for the applied FOR UPDATE clause.
void	LockProvider.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(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(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.setForUpdateSkipLocked() Some RDBMS allow for specifying the locking mode for the applied FOR UPDATE clause.
void	LockProvider.setForUpdateWait(int seconds) Some RDBMS allow for specifying the locking mode for the applied FOR UPDATE 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<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.
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 TableRecord<R>> 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 MERGE statement
MergeOnStep<R>	MergeUsingStep.usingDual() Add a dummy USING clause to the 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
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
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
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.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

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 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 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<?> 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<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> 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 <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) Get a typed Field for a literal.
static <T> Field<T>	Factory.literal(Object literal, DataType<T> type) Get a typed Field for a literal.
static <T> Field<T>	Factory.literal(T literal) Get a typed Field for a literal.
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])
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> value) 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) This is known to be supported in any of these RDBMS: HSQLDB Oracle Sybase SQL Anywhere
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.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 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])
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 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])))
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 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) This is known to be supported in any of these RDBMS: DB2 H2 HSQLDB Ingres MySQL Oracle Postgres SQL Server (stdev) Sybase ASE Sybase SQL Anywhere
static AggregateFunction<BigDecimal>	Factory.stddevSamp(Field<? extends Number> field) Get the sample standard deviation of a numeric field: stddev_samp(field) This is known to be supported in any of these RDBMS: DB2 H2 HSQLDB Ingres MySQL Oracle Postgres SQL Server (stdev) Sybase ASE Sybase SQL Anywhere
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 PlainSQLTable is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
static Table<Record>	Factory.table(String sql, Object... bindings) A PlainSQLTable is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
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<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 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) 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) 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) 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) This is known to be supported in any of these RDBMS: DB2 H2 HSQLDB Ingres MySQL Oracle Postgres SQL Server (stdev) Sybase ASE Sybase SQL Anywhere
static AggregateFunction<BigDecimal>	Factory.varSamp(Field<? extends Number> field) Get the sample variance of a numeric field: var_samp(field) This is known to be supported in any of these RDBMS: H2 HSQLDB Ingres MySQL Oracle Postgres SQL Server (var) Sybase SQL Anywhere
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.