Field<T> |
Field.abs()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.acos()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.add(Field<?> value)
An arithmetic expression to add value to this.
|
Field<T> |
Field.add(Number value)
An arithmetic expression adding this to value.
|
void |
UpdateQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
SimpleSelectQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
SelectQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
DeleteQuery.addConditions(Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
ConditionProvider.addConditions(Collection<Condition> conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
UpdateQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
SimpleSelectQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
SelectQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
DeleteQuery.addConditions(Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
ConditionProvider.addConditions(Condition... conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with Operator.AND
|
void |
UpdateQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
SimpleSelectQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
SelectQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
DeleteQuery.addConditions(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
ConditionProvider.addConditions(Operator operator,
Collection<Condition> conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
UpdateQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
SimpleSelectQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
SelectQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
DeleteQuery.addConditions(Operator operator,
Condition... conditions)
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
ConditionProvider.addConditions(Operator operator,
Condition... conditions)
Deprecated.
Adds new conditions to the query, connecting them to existing
conditions with the provided operator
|
void |
SelectQuery.addConnectBy(Condition condition)
Add an Oracle-specific CONNECT BY clause to the query
|
void |
SelectQuery.addConnectByNoCycle(Condition condition)
Add an Oracle-specific CONNECT BY NOCYCLE clause to the
query
|
void |
SelectQuery.addFrom(Collection<? extends TableLike<?>> from)
Add tables to the table product
|
void |
SelectQuery.addFrom(TableLike<?>... from)
Add tables to the table product
|
void |
SelectQuery.addGroupBy(Collection<? extends Field<?>> fields)
Adds grouping fields
Calling this with an empty argument list will result in an empty
GROUP BY () clause being rendered.
|
void |
SelectQuery.addGroupBy(Field<?>... fields)
Adds grouping fields
Calling this with an empty argument list will result in an empty
GROUP BY () clause being rendered.
|
void |
SelectQuery.addHaving(Collection<Condition> conditions)
Adds new conditions to the having clause of the query, connecting it to
existing conditions with the and operator.
|
void |
SelectQuery.addHaving(Condition... conditions)
Adds new conditions to the having clause of the query, connecting it to
existing conditions with the and operator.
|
void |
SelectQuery.addHaving(Operator operator,
Collection<Condition> conditions)
Adds new conditions to the having clause of query, connecting them to
existing conditions with the provided operator
|
void |
SelectQuery.addHaving(Operator operator,
Condition... conditions)
Adds new conditions to the having clause of query, connecting them to
existing conditions with the provided operator
|
void |
SelectQuery.addHint(String hint)
Add an Oracle-style hint to the select clause
Example:
Factory create = new Factory();
create.select(field1, field2)
.hint("/*+ALL_ROWS*/")
.from(table1)
.execute();
|
void |
SelectQuery.addJoin(TableLike<?> table,
Condition... conditions)
Joins the existing table product to a new table using a condition
|
void |
SelectQuery.addJoin(TableLike<?> table,
JoinType type,
Condition... conditions)
Joins the existing table product to a new table using a condition
|
void |
SelectQuery.addJoin(TableLike<?> table,
JoinType type,
Condition[] conditions,
Field<?>[] partitionBy)
Joins the existing table product to a new table using a condition
This adds a PARTITION BY clause to the right hand side of a
OUTER JOIN expression.
|
void |
SelectQuery.addJoinOnKey(TableLike<?> table,
JoinType type)
Joins the existing table product to a new table using a foreign key
|
void |
SelectQuery.addJoinOnKey(TableLike<?> table,
JoinType type,
ForeignKey<?,?> key)
Joins the existing table product to a new table using a foreign key
|
void |
SelectQuery.addJoinOnKey(TableLike<?> table,
JoinType type,
TableField<?,?>... keyFields)
Joins the existing table product to a new table using a foreign key
|
void |
SelectQuery.addJoinUsing(TableLike<?> table,
Collection<? extends Field<?>> fields)
Joins the existing table product to a new table with a USING
clause
If this is not supported by your RDBMS, then jOOQ will try to simulate
this behaviour using the information provided in this query.
|
void |
SelectQuery.addJoinUsing(TableLike<?> table,
JoinType type,
Collection<? extends Field<?>> fields)
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 |
SimpleSelectQuery.addLimit(int numberOfRows)
|
void |
SelectQuery.addLimit(int numberOfRows)
|
void |
OrderProvider.addLimit(int numberOfRows)
Deprecated.
|
void |
SimpleSelectQuery.addLimit(int offset,
int numberOfRows)
Limit the results of this select
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SelectQuery.addLimit(int offset,
int numberOfRows)
Limit the results of this select
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
OrderProvider.addLimit(int offset,
int numberOfRows)
Deprecated.
Limit the results of this select
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SimpleSelectQuery.addLimit(int offset,
Param<Integer> numberOfRows)
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SelectQuery.addLimit(int offset,
Param<Integer> numberOfRows)
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
OrderProvider.addLimit(int offset,
Param<Integer> numberOfRows)
Deprecated.
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SimpleSelectQuery.addLimit(Param<Integer> numberOfRows)
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SelectQuery.addLimit(Param<Integer> numberOfRows)
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
OrderProvider.addLimit(Param<Integer> numberOfRows)
Deprecated.
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SimpleSelectQuery.addLimit(Param<Integer> offset,
int numberOfRows)
Limit the results of this select
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SelectQuery.addLimit(Param<Integer> offset,
int numberOfRows)
Limit the results of this select
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
OrderProvider.addLimit(Param<Integer> offset,
int numberOfRows)
Deprecated.
Limit the results of this select
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SimpleSelectQuery.addLimit(Param<Integer> offset,
Param<Integer> numberOfRows)
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SelectQuery.addLimit(Param<Integer> offset,
Param<Integer> numberOfRows)
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
OrderProvider.addLimit(Param<Integer> offset,
Param<Integer> numberOfRows)
Deprecated.
Limit the results of this select using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
void |
SimpleSelectQuery.addOrderBy(Collection<SortField<?>> fields)
Adds ordering fields
|
void |
SelectQuery.addOrderBy(Collection<SortField<?>> fields)
Adds ordering fields
|
void |
OrderProvider.addOrderBy(Collection<SortField<?>> fields)
Deprecated.
Adds ordering fields
|
void |
SimpleSelectQuery.addOrderBy(Field<?>... fields)
Adds ordering fields, ordering by the default sort order
|
void |
SelectQuery.addOrderBy(Field<?>... fields)
Adds ordering fields, ordering by the default sort order
|
void |
OrderProvider.addOrderBy(Field<?>... fields)
Deprecated.
Adds ordering fields, ordering by the default sort order
|
void |
SimpleSelectQuery.addOrderBy(int... fieldIndexes)
Adds ordering fields
Indexes start at 1 in SQL!
|
void |
SelectQuery.addOrderBy(int... fieldIndexes)
Adds ordering fields
Indexes start at 1 in SQL!
|
void |
OrderProvider.addOrderBy(int... fieldIndexes)
Deprecated.
Adds ordering fields
Indexes start at 1 in SQL!
|
void |
SimpleSelectQuery.addOrderBy(SortField<?>... fields)
Adds ordering fields
|
void |
SelectQuery.addOrderBy(SortField<?>... fields)
Adds ordering fields
|
void |
OrderProvider.addOrderBy(SortField<?>... fields)
Deprecated.
Adds ordering fields
|
void |
InsertQuery.addRecord(R record)
Short for calling
newRecord();
setRecord(record);
|
void |
SelectQuery.addSelect(Collection<? extends Field<?>> fields)
Add a list of select fields
|
void |
SelectQuery.addSelect(Field<?>... fields)
Add a list of select fields
|
<T> void |
StoreQuery.addValue(Field<T> field,
Field<T> value)
Add a value to the store statement
|
<T> void |
StoreQuery.addValue(Field<T> field,
T value)
Add a value to the store statement
|
<A extends ArrayRecord<T>,T> void |
StoreQuery.addValueAsArray(Field<A> field,
List<T> value)
Add a value to the store statement
|
<A extends ArrayRecord<T>,T> void |
StoreQuery.addValueAsArray(Field<A> field,
T... value)
Add a value to the store statement
|
<T> void |
InsertQuery.addValueForUpdate(Field<T> field,
Field<T> value)
Add a value to the ON DUPLICATE KEY UPDATE clause of this
INSERT statement, where this is supported.
|
<T> void |
InsertQuery.addValueForUpdate(Field<T> field,
T value)
Add a value to the ON DUPLICATE KEY UPDATE clause of this
INSERT statement, where this is supported.
|
void |
StoreQuery.addValues(Map<? extends Field<?>,?> map)
Add multiple values to the store statement.
|
void |
InsertQuery.addValuesForUpdate(Map<? extends Field<?>,?> map)
Add multiple values to the ON DUPLICATE KEY UPDATE clause of
this INSERT statement, where this is supported.
|
UpdateConditionStep<R> |
UpdateConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator
|
TableOnConditionStep |
TableOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConnectByConditionStep |
SelectConnectByConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
DeleteConditionStep<R> |
DeleteConditionStep.and(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.AND operator
|
Condition |
Condition.and(Condition other)
Combine this condition with another one using the Operator.AND
operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConnectByConditionStep |
SelectConnectByConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.and(String sql)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
Condition |
Condition.and(String sql)
Combine this condition with another one using the Operator.AND
operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConnectByConditionStep |
SelectConnectByConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.and(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
Condition |
Condition.and(String sql,
Object... bindings)
Combine this condition with another one using the Operator.AND
operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConnectByConditionStep |
SelectConnectByConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.and(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.AND operator.
|
Condition |
Condition.and(String sql,
QueryPart... parts)
Combine this condition with another one using the Operator.AND
operator.
|
WindowFinalStep<T> |
WindowRowsAndStep.andCurrentRow()
Add a ...
|
UpdateConditionStep<R> |
UpdateConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.AND operator
|
TableOnConditionStep |
TableOnConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS
clause using the Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.andExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS
clause using the Operator.AND operator.
|
Condition |
Condition.andExists(Select<?> select)
Combine this condition with an EXISTS clause using the
Operator.AND operator.
|
WindowFinalStep<T> |
WindowRowsAndStep.andFollowing(int number)
Add a ...
|
UpdateConditionStep<R> |
UpdateConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator
|
TableOnConditionStep |
TableOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.andNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.AND operator.
|
Condition |
Condition.andNot(Condition other)
Combine this condition with a negated other one using the
Operator.AND operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.AND operator
|
TableOnConditionStep |
TableOnConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS
clause using the Operator.AND operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.AND operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.andNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS
clause using the Operator.AND operator.
|
Condition |
Condition.andNotExists(Select<?> select)
Combine this condition with a NOT EXIST clause using the
Operator.AND operator.
|
WindowFinalStep<T> |
WindowRowsAndStep.andPreceding(int number)
Add a ...
|
WindowFinalStep<T> |
WindowRowsAndStep.andUnboundedFollowing()
Add a ...
|
WindowFinalStep<T> |
WindowRowsAndStep.andUnboundedPreceding()
Add a ...
|
Table<R> |
Table.as(String alias)
Create an alias for this table
|
Field<T> |
Field.as(String alias)
Create an alias for this field
|
Z |
AliasProvider.as(String alias)
Deprecated.
Get an aliased QueryPart.
|
SortField<T> |
Field.asc()
|
Field<Integer> |
Field.ascii()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.asin()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.atan()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.atan2(Field<? extends Number> y)
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.atan2(Number y)
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.avg()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<BigDecimal> |
Field.avgOver()
This method is part of the pre-2.0 API.
|
Batch |
FactoryOperations.batch(Collection<? extends Query> queries)
Execute a set of queries in batch mode (without bind values).
|
Batch |
FactoryOperations.batch(Query... queries)
Execute a set of queries in batch mode (without bind values).
|
BatchBindStep |
FactoryOperations.batch(Query query)
Execute a set of queries in batch mode (with bind values).
|
BetweenAndStep<T> |
Field.between(Field<T> minValue)
Create a condition to check this field against some bounds
SQL: this between minValue and maxValue
|
Condition |
Field.between(Field<T> minValue,
Field<T> maxValue)
Create a condition to check this field against some bounds
This is the same as calling
between(minValue).and(maxValue)
SQL: this between minValue and maxValue
|
BetweenAndStep<T> |
Field.between(T minValue)
Create a condition to check this field against some bounds
SQL: this between minValue and maxValue
|
Condition |
Field.between(T minValue,
T maxValue)
Create a condition to check this field against some bounds
This is the same as calling
between(minValue).and(maxValue)
SQL: this between minValue and maxValue
|
BetweenAndStep<T> |
Field.betweenSymmetric(Field<T> minValue)
Create a condition to check this field against some bounds
SQL: this between symmetric minValue and maxValue
|
Condition |
Field.betweenSymmetric(Field<T> minValue,
Field<T> maxValue)
Create a condition to check this field against some bounds
This is the same as calling
betweenSymmetric(minValue).and(maxValue)
SQL: this between symmetric minValue and maxValue
|
BetweenAndStep<T> |
Field.betweenSymmetric(T minValue)
Create a condition to check this field against some bounds
SQL: this between symmetric minValue and maxValue
|
Condition |
Field.betweenSymmetric(T minValue,
T maxValue)
Create a condition to check this field against some bounds
This is the same as calling
betweenSymmetric(minValue).and(maxValue)
SQL: this between symmetric minValue and maxValue
|
Field<Integer> |
Field.bitLength()
This method is part of the pre-2.0 API.
|
<Z> Field<Z> |
Field.cast(Class<? extends Z> type)
Cast this field to another type
The actual cast may not be accurate as the DataType has to be
"guessed" from the jOOQ-configured data types.
|
<Z> Field<Z> |
Field.cast(DataType<Z> type)
Cast this field to a dialect-specific data type.
|
<Z> Field<Z> |
Field.cast(Field<Z> field)
Cast this field to the type of another field.
|
Field<T> |
Field.ceil()
This method is part of the pre-2.0 API.
|
Field<Integer> |
Field.charLength()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.coalesce(Field<T> option,
Field<?>... options)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.coalesce(T option,
T... options)
This method is part of the pre-2.0 API.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.commitAfter(int number)
Commit after a certain number of inserted records.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.commitAll()
Commit only after inserting all records.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.commitEach()
Commit each loaded record.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.commitNone()
Leave committing / rollbacking up to client code.
|
Condition |
Field.compare(Comparator comparator,
Field<T> field)
Compare this field with another field using a dynamic comparator
|
Condition |
Field.compare(Comparator comparator,
T value)
Compare this field with a value using a dynamic comparator
|
Field<String> |
Field.concat(Field<?>... fields)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.concat(String... values)
This method is part of the pre-2.0 API.
|
SelectConnectByConditionStep |
SelectConnectByStep.connectBy(Condition condition)
Add an Oracle-specific CONNECT BY clause to the query
|
SelectConnectByConditionStep |
SelectConnectByStep.connectBy(String sql)
Add an Oracle-specific CONNECT BY clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConnectByConditionStep |
SelectConnectByStep.connectBy(String sql,
Object... bindings)
Add an Oracle-specific CONNECT BY clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConnectByConditionStep |
SelectConnectByStep.connectBy(String sql,
QueryPart... parts)
Add an Oracle-specific CONNECT BY clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConnectByConditionStep |
SelectConnectByStep.connectByNoCycle(Condition condition)
Add an Oracle-specific CONNECT BY NOCYCLE clause to the
query
|
SelectConnectByConditionStep |
SelectConnectByStep.connectByNoCycle(String sql)
Add an Oracle-specific CONNECT BY NOCYCLE clause to the
query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConnectByConditionStep |
SelectConnectByStep.connectByNoCycle(String sql,
Object... bindings)
Add an Oracle-specific CONNECT BY NOCYCLE clause to the
query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConnectByConditionStep |
SelectConnectByStep.connectByNoCycle(String sql,
QueryPart... parts)
Add an Oracle-specific CONNECT BY NOCYCLE clause to the
query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
Condition |
Field.contains(Field<T> value)
Convenience method for Field.like(String, char) including proper
adding of wildcards and escaping
SQL: this like ('%' || escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance
val(1133).contains(13)
If you're using SQLDialect.POSTGRES , then you can use this method
also to express the "ARRAY contains" operator.
|
Condition |
Field.contains(T value)
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)
|
Table<Record> |
Table.crossJoin(String sql,
QueryPart... parts)
CROSS JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.crossJoin(String sql,
QueryPart... parts)
|
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)
|
MergeNotMatchedStep<R> |
MergeMatchedDeleteStep.deleteWhere(Condition condition)
Add an additional DELETE WHERE clause to the preceding
WHEN MATCHED THEN UPDATE clause.
|
SortField<T> |
Field.desc()
|
Field<T> |
Field.div(Field<? extends Number> value)
An arithmetic expression dividing this by value
If this is a numeric field, then the result is a number of the same
type as this field.
|
Field<T> |
Field.div(Number value)
An arithmetic expression dividing this by value
If this is a numeric field, then the result is a number of the same
type as this field.
|
DivideByOnStep |
Table.divideBy(Table<?> divisor)
Create a new TABLE reference from this table, applying
relational division.
|
Condition |
Field.endsWith(Field<T> value)
Convenience method for Field.like(String, char) including proper
adding of wildcards and escaping
SQL: this like ('%' || escape(value, '\')) escape '\'
Note: This also works with numbers, for instance
val(1133).endsWith(33)
|
Condition |
Field.endsWith(T value)
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 |
RowN.eq(Field<?>... values)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Field.eq(Field<T> field)
this = field
|
Condition |
Row1.eq(Field<T1> t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row2.eq(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row3.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row4.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row5.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row6.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row7.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row8.eq(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
RowN.eq(Object... values)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row1.eq(Row1<T1> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row2.eq(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row3.eq(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row4.eq(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row5.eq(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row6.eq(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row7.eq(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row8.eq(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
RowN.eq(RowN row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Field.eq(Select<?> query)
this = (Select
|
Condition |
Field.eq(T value)
this = value
If value == null , then this will return a condition
equivalent to Field.isNull() for convenience.
|
Condition |
Row1.eq(T1 t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row2.eq(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row3.eq(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row4.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row5.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row6.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row7.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row8.eq(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
RowN.equal(Field<?>... fields)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Field.equal(Field<T> field)
this = field
|
Condition |
Row1.equal(Field<T1> t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row2.equal(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row3.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row4.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row5.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row6.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row7.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row8.equal(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
RowN.equal(Object... values)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row1.equal(Row1<T1> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row2.equal(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row3.equal(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row4.equal(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row5.equal(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row6.equal(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row7.equal(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row8.equal(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
RowN.equal(RowN row)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Field.equal(Select<?> query)
this = (Select
|
Condition |
Field.equal(T value)
this = value
If value == null , then this will return a condition
equivalent to Field.isNull() for convenience.
|
Condition |
Row1.equal(T1 t1)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row2.equal(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row3.equal(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row4.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row5.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row6.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row7.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Row8.equal(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for equality
Row equality comparison predicates can be simulated in those databases
that do not support such predicates natively:
(A, B) = (1, 2) is equivalent to
A = 1 AND B = 2
|
Condition |
Field.equalAll(Field<T[]> array)
|
Condition |
Field.equalAll(Select<?> query)
this = all (Select
|
Condition |
Field.equalAll(T... array)
|
Condition |
Field.equalAny(Field<T[]> array)
|
Condition |
Field.equalAny(Select<?> query)
this = any (Select
|
Condition |
Field.equalAny(T... array)
|
Condition |
Field.equalIgnoreCase(Field<String> value)
lower(this) = lower(value)
|
Condition |
Field.equalIgnoreCase(String value)
lower(this) = lower(value)
|
Condition |
Field.equalSome(Select<?> query)
|
Select<R> |
Select.except(Select<R> select)
Combine with other selects
|
Loader<R> |
LoaderLoadStep.execute()
Execute the load.
|
int |
FactoryOperations.execute(String sql)
Execute a query holding plain SQL.
|
int |
FactoryOperations.execute(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
int |
FactoryOperations.execute(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends UpdatableRecord<R>> int |
FactoryOperations.executeDelete(R record)
Delete a record from a table
DELETE FROM [table] WHERE [record is supplied record]
|
<R extends TableRecord<R>,T> int |
FactoryOperations.executeDelete(R record,
Condition condition)
Delete a record from a table
DELETE FROM [table] WHERE [condition]
|
<R extends TableRecord<R>> int |
FactoryOperations.executeDelete(Table<R> table)
|
<R extends TableRecord<R>,T> int |
FactoryOperations.executeDelete(Table<R> table,
Condition condition)
|
<R extends TableRecord<R>> int |
FactoryOperations.executeDeleteOne(Table<R> table)
|
<R extends TableRecord<R>,T> int |
FactoryOperations.executeDeleteOne(Table<R> table,
Condition condition)
|
<R extends TableRecord<R>> int |
FactoryOperations.executeInsert(R record)
Insert one record
This executes something like the following statement:
INSERT INTO [table] ...
|
<R extends TableRecord<R>> int |
FactoryOperations.executeInsert(Table<R> table,
R record)
|
<R extends UpdatableRecord<R>> int |
FactoryOperations.executeUpdate(R record)
Update a table
UPDATE [table] SET [modified values in record] WHERE [record is supplied record]
|
<R extends TableRecord<R>,T> int |
FactoryOperations.executeUpdate(R record,
Condition condition)
Update a table
UPDATE [table] SET [modified values in record] WHERE [condition]
|
<R extends TableRecord<R>> int |
FactoryOperations.executeUpdate(Table<R> table,
R record)
Deprecated.
- 2.5.0 [#1692] - This "mass" update is no longer supported
|
<R extends TableRecord<R>,T> int |
FactoryOperations.executeUpdate(Table<R> table,
R record,
Condition condition)
|
<R extends TableRecord<R>> int |
FactoryOperations.executeUpdateOne(Table<R> table,
R record)
Deprecated.
- 2.5.0 [#1692] - This "mass" update is no longer supported
|
<R extends TableRecord<R>,T> int |
FactoryOperations.executeUpdateOne(Table<R> table,
R record,
Condition condition)
|
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)
|
Result<Record> |
FactoryOperations.fetch(String sql)
Execute a new query holding plain SQL.
|
Result<Record> |
FactoryOperations.fetch(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Result<Record> |
FactoryOperations.fetch(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends Record> Result<R> |
FactoryOperations.fetch(Table<R> table)
Execute and return all records for
SELECT * FROM [table]
The result and its contained records are attached to this
Configuration by default.
|
<R extends Record> Result<R> |
FactoryOperations.fetch(Table<R> table,
Condition condition)
Execute and return all records for
SELECT * FROM [table] WHERE [condition]
The result and its contained records are attached to this
Configuration by default.
|
<R extends Record> R |
FactoryOperations.fetchAny(Table<R> table)
Execute and return zero or one record for
SELECT * FROM [table] LIMIT 1
The resulting record is attached to this Configuration by
default.
|
Cursor<Record> |
FactoryOperations.fetchLazy(ResultSet rs)
|
Cursor<Record> |
FactoryOperations.fetchLazy(String sql)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
FactoryOperations.fetchLazy(String sql,
Object... bindings)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
FactoryOperations.fetchLazy(String sql,
QueryPart... parts)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
List<Result<Record>> |
FactoryOperations.fetchMany(String sql)
Execute a new query holding plain SQL, possibly returning several result
sets
Example (Sybase ASE):
String sql = "sp_help 'my_table'";
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
List<Result<Record>> |
FactoryOperations.fetchMany(String sql,
Object... bindings)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
List<Result<Record>> |
FactoryOperations.fetchMany(String sql,
QueryPart... parts)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
R |
InsertResultStep.fetchOne()
|
Record |
FactoryOperations.fetchOne(String sql)
Execute a new query holding plain SQL.
|
Record |
FactoryOperations.fetchOne(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Record |
FactoryOperations.fetchOne(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends Record> R |
FactoryOperations.fetchOne(Table<R> table)
Execute and return zero or one record for
SELECT * FROM [table]
The resulting record is attached to this Configuration by
default.
|
<R extends Record> R |
FactoryOperations.fetchOne(Table<R> table,
Condition condition)
Execute and return zero or one record for
SELECT * FROM [table] WHERE [condition]
The resulting record is attached to this Configuration by
default.
|
LoaderCSVOptionsStep<R> |
LoaderCSVStep.fields(Collection<? extends Field<?>> fields)
Specify the the fields to be loaded into the table in the correct order.
|
LoaderCSVOptionsStep<R> |
LoaderCSVStep.fields(Field<?>... fields)
Specify the the fields to be loaded into the table in the correct order.
|
WindowIgnoreNullsStep<T> |
Field.firstValue()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.floor()
This method is part of the pre-2.0 API.
|
SimpleSelectFinalStep<R> |
SimpleSelectForUpdateStep.forShare()
Add a FOR SHARE clause to the end of the query.
|
SelectFinalStep |
SelectForUpdateStep.forShare()
Add a FOR SHARE clause to the end of the query.
|
SimpleSelectForUpdateOfStep<R> |
SimpleSelectForUpdateStep.forUpdate()
Add a FOR UPDATE clause to the end of the query.
|
SelectForUpdateOfStep |
SelectForUpdateStep.forUpdate()
Add a FOR UPDATE clause to the end of the query.
|
SelectJoinStep |
SelectFromStep.from(Collection<? extends TableLike<?>> tables)
Add a FROM clause to the query
|
SelectJoinStep |
SelectFromStep.from(String sql)
Add a FROM clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectJoinStep |
SelectFromStep.from(String sql,
Object... bindings)
Add a FROM clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectJoinStep |
SelectFromStep.from(String sql,
QueryPart... parts)
Add a FROM clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectJoinStep |
SelectFromStep.from(TableLike<?>... table)
Add a FROM clause to the query
|
TableOnStep |
Table.fullOuterJoin(String sql)
FULL OUTER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.fullOuterJoin(String sql)
Convenience method to FULL OUTER JOIN a table to the last
table added to the FROM clause using
Table.fullOuterJoin(String)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnStep |
Table.fullOuterJoin(String sql,
Object... bindings)
FULL OUTER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.fullOuterJoin(String sql,
Object... bindings)
|
TableOnStep |
Table.fullOuterJoin(String sql,
QueryPart... parts)
FULL OUTER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.fullOuterJoin(String sql,
QueryPart... parts)
|
TableOnStep |
Table.fullOuterJoin(TableLike<?> table)
FULL OUTER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.fullOuterJoin(TableLike<?> table)
Convenience method to FULL OUTER JOIN a table to the last
table added to the FROM clause using
Table.fullOuterJoin(TableLike)
This is only possible where the underlying RDBMS supports it
|
Condition |
Field.ge(Field<T> field)
this >= field
|
Condition |
Field.ge(Select<?> query)
this >= (Select
|
Condition |
Field.ge(T value)
this >= value
|
R |
InsertQuery.getReturnedRecord()
|
Result<R> |
InsertQuery.getReturnedRecords()
|
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)
|
Condition |
Field.greaterOrEqualAll(Select<?> query)
this >= all (Select
|
Condition |
Field.greaterOrEqualAll(T... array)
|
Condition |
Field.greaterOrEqualAny(Field<T[]> array)
|
Condition |
Field.greaterOrEqualAny(Select<?> query)
this >= any (Select
|
Condition |
Field.greaterOrEqualAny(T... array)
|
Condition |
Field.greaterOrEqualSome(Select<?> query)
|
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)
|
Condition |
Field.greaterThanAll(Select<?> query)
this > all (Select
|
Condition |
Field.greaterThanAll(T... array)
|
Condition |
Field.greaterThanAny(Field<T[]> array)
|
Condition |
Field.greaterThanAny(Select<?> query)
this > any (Select
|
Condition |
Field.greaterThanAny(T... array)
|
Condition |
Field.greaterThanSome(Select<?> query)
|
Field<T> |
Field.greatest(Field<?>... others)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.greatest(T... others)
This method is part of the pre-2.0 API.
|
SelectHavingStep |
SelectGroupByStep.groupBy(Collection<? extends Field<?>> fields)
Add a GROUP BY clause to the query
Calling this with an empty argument list will result in an empty
GROUP BY () clause being rendered.
|
SelectHavingStep |
SelectGroupByStep.groupBy(Field<?>... fields)
Add a GROUP BY clause to the query
Calling this with an empty argument list will result in an empty
GROUP BY () clause being rendered.
|
Condition |
Field.gt(Field<T> field)
this > field
|
Condition |
Field.gt(Select<?> query)
this > (Select
|
Condition |
Field.gt(T value)
this > value
|
SelectHavingConditionStep |
SelectHavingStep.having(Collection<Condition> conditions)
Add a HAVING clause to the query
|
SelectHavingConditionStep |
SelectHavingStep.having(Condition... conditions)
Add a HAVING clause to the query
|
SelectHavingConditionStep |
SelectHavingStep.having(String sql)
Add a HAVING clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectHavingConditionStep |
SelectHavingStep.having(String sql,
Object... bindings)
Add a HAVING clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectHavingConditionStep |
SelectHavingStep.having(String sql,
QueryPart... parts)
Add a HAVING clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectFromStep |
SelectFromStep.hint(String hint)
Add an Oracle-style hint to the preceding select clause
Example:
Factory create = new Factory();
create.select(field1, field2)
.hint("/*+ALL_ROWS*/")
.from(table1)
.execute();
|
WindowOverStep<T> |
WindowIgnoreNullsStep.ignoreNulls()
Add an IGNORE NULLS clause to the window function.
|
LoaderCSVOptionsStep<R> |
LoaderCSVOptionsStep.ignoreRows(int number)
Specify that a certain number of rows should be ignored from the CSV
file.
|
Table<Record> |
PivotInStep.in(Collection<? extends Field<T>> fields)
Specify the acceptable values for pivoting
This clause is generally only supported by SQLDialect.ORACLE .
|
Condition |
Row1.in(Collection<? extends Row1<T1>> row)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row2.in(Collection<? extends Row2<T1,T2>> rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row3.in(Collection<? extends Row3<T1,T2,T3>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row4.in(Collection<? extends Row4<T1,T2,T3,T4>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row5.in(Collection<? extends Row5<T1,T2,T3,T4,T5>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row6.in(Collection<? extends Row6<T1,T2,T3,T4,T5,T6>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row7.in(Collection<? extends Row7<T1,T2,T3,T4,T5,T6,T7>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row8.in(Collection<? extends Row8<T1,T2,T3,T4,T5,T6,T7,T8>> rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
RowN.in(Collection<? extends RowN> rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Field.in(Collection<T> values)
Create a condition to check this field against several values
SQL: this in (values...)
|
Table<Record> |
PivotInStep.in(Field<?>... fields)
Specify the acceptable values for pivoting
This clause is generally only supported by SQLDialect.ORACLE .
|
Condition |
Field.in(Field<?>... values)
Create a condition to check this field against several values
SQL: this in (values...)
|
Condition |
Row1.in(Row1<T1>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row2.in(Row2<T1,T2>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row3.in(Row3<T1,T2,T3>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row4.in(Row4<T1,T2,T3,T4>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row5.in(Row5<T1,T2,T3,T4,T5>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row6.in(Row6<T1,T2,T3,T4,T5,T6>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row7.in(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row8.in(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)
Compare this row value expression with a set of row value expressions for equality
Row IN predicates can be simulated in those databases that do not
support such predicates natively: (A, B) IN ((1, 2), (3, 4))
is equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) ,
which is equivalent to
(A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
RowN.in(RowN... rows)
Compare this row value expression with a set of row value expressions for
equality
Row IN predicates can be simulated in those databases that do not support
such predicates natively: (A, B) IN ((1, 2), (3, 4)) is
equivalent to ((A, B) = (1, 2)) OR ((A, B) = (3, 4)) , which
is equivalent to (A = 1 AND B = 2) OR (A = 3 AND B = 4)
|
Condition |
Row.in(Select<?> select)
Compare this row value expression with a subselect for equality
Note that the subquery must return a table of the same degree as this row
value expression.
|
Condition |
Field.in(Select<?> query)
Create a condition to check this field against a subquery
Note that the subquery must return exactly one field.
|
Table<Record> |
PivotInStep.in(T... values)
Specify the acceptable values for pivoting
|
Condition |
Field.in(T... values)
Create a condition to check this field against several values
SQL: this in (values...)
|
<R extends Record> InsertSetStep<R> |
FactoryOperations.insertInto(Table<R> into)
Create a new DSL insert statement.
|
<R extends Record> InsertValuesStep<R> |
FactoryOperations.insertInto(Table<R> into,
Collection<? extends Field<?>> fields)
Create a new DSL insert statement.
|
<R extends Record> InsertValuesStep<R> |
FactoryOperations.insertInto(Table<R> into,
Field<?>... fields)
Create a new DSL insert statement.
|
<R extends Record> Insert<R> |
FactoryOperations.insertInto(Table<R> into,
Select<?> select)
Deprecated.
- 2.0.3 - Use any of these methods instead:
|
<R extends Record> InsertQuery<R> |
FactoryOperations.insertQuery(Table<R> into)
|
Select<R> |
Select.intersect(Select<R> select)
Combine with other selects
|
boolean |
Parameter.isDefaulted()
Whether this parameter has a default value
Procedures and functions with defaulted parameters behave slightly
different from ones without defaulted parameters.
|
Condition |
Field.isDistinctFrom(Field<T> field)
Create a condition to check if this field is DISTINCT from
another field
If this is not supported by the underlying database, jOOQ will render
this instead:
CASE WHEN [this] IS NULL AND [field] IS NULL THEN FALSE
WHEN [this] IS NULL AND [field] IS NOT NULL THEN TRUE
WHEN [this] IS NOT NULL AND [field] IS NULL THEN TRUE
WHEN [this] = [field] THEN FALSE
ELSE TRUE
END
SQL: this is distinct from field
|
Condition |
Field.isDistinctFrom(T value)
Create a condition to check if this field is DISTINCT from
another value
If this is not supported by the underlying database, jOOQ will render
this instead:
CASE WHEN [this] IS NULL AND [value] IS NULL THEN FALSE
WHEN [this] IS NULL AND [value] IS NOT NULL THEN TRUE
WHEN [this] IS NOT NULL AND [value] IS NULL THEN TRUE
WHEN [this] = [value] THEN FALSE
ELSE TRUE
END
SQL: this is distinct from value
|
Condition |
Field.isFalse()
Create a condition to check this field against known string literals for
false
SQL:
lcase(this) in ("0", "n", "no", "false", "off", "disabled")
|
Condition |
Field.isNotDistinctFrom(Field<T> field)
Create a condition to check if this field is NOT DISTINCT
from another field
If this is not supported by the underlying database, jOOQ will render
this instead:
CASE WHEN [this] IS NULL AND [field] IS NULL THEN TRUE
WHEN [this] IS NULL AND [field] IS NOT NULL THEN FALSE
WHEN [this] IS NOT NULL AND [field] IS NULL THEN FALSE
WHEN [this] = [value] THEN TRUE
ELSE FALSE
END
SQL: this is not distinct from field
|
Condition |
Field.isNotDistinctFrom(T value)
Create a condition to check if this field is NOT DISTINCT
from another value
If this is not supported by the underlying database, jOOQ will render
this instead:
CASE WHEN [this] IS NULL AND [value] IS NULL THEN TRUE
WHEN [this] IS NULL AND [value] IS NOT NULL THEN FALSE
WHEN [this] IS NOT NULL AND [value] IS NULL THEN FALSE
WHEN [this] = [value] THEN TRUE
ELSE FALSE
END
SQL: this is not distinct from value
|
Condition |
Field.isNotNull()
Create a condition to check this field against null .
|
Condition |
Field.isNull()
Create a condition to check this field against null .
|
Condition |
Field.isTrue()
Create a condition to check this field against known string literals for
true
SQL:
lcase(this) in ("1", "y", "yes", "true", "on", "enabled")
|
TableOnStep |
Table.join(String sql)
INNER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.join(String sql)
Convenience method to INNER JOIN a table to the last table
added to the FROM clause using Table.join(String)
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnStep |
Table.join(String sql,
Object... bindings)
INNER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.join(String sql,
Object... bindings)
|
TableOnStep |
Table.join(String sql,
QueryPart... parts)
INNER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.join(String sql,
QueryPart... parts)
|
TableOnStep |
Table.join(TableLike<?> table)
INNER JOIN a table to this table.
|
SelectOnStep |
SelectJoinStep.join(TableLike<?> table)
Convenience method to INNER JOIN a table to the last table
added to the FROM clause using Table.join(TableLike)
|
TableOptionalOnStep |
Table.join(TableLike<?> table,
JoinType type)
|
SelectOptionalOnStep |
SelectJoinStep.join(TableLike<?> table,
JoinType type)
|
WindowBeforeOverStep<T> |
AggregateFunction.keepDenseRankFirstOrderBy(Collection<SortField<?>> fields)
Restrict this aggregate function to FIRST values
An example:
MAX(ID) KEEP (DENSE_RANK FIRST ORDER BY 1)
This clause is only available on
MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.
|
WindowBeforeOverStep<T> |
AggregateFunction.keepDenseRankFirstOrderBy(Field<?>... fields)
Restrict this aggregate function to FIRST values
An example:
MAX(ID) KEEP (DENSE_RANK FIRST ORDER BY 1)
This clause is only available on
MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.
|
WindowBeforeOverStep<T> |
AggregateFunction.keepDenseRankFirstOrderBy(SortField<?>... fields)
Restrict this aggregate function to FIRST values
An example:
MAX(ID) KEEP (DENSE_RANK FIRST ORDER BY 1)
This clause is only available on
MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.
|
WindowBeforeOverStep<T> |
AggregateFunction.keepDenseRankLastOrderBy(Collection<SortField<?>> fields)
Restrict this aggregate function to FIRST values
An example:
MAX(ID) KEEP (DENSE_RANK LAST ORDER BY 1)
This clause is only available on
MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.
|
WindowBeforeOverStep<T> |
AggregateFunction.keepDenseRankLastOrderBy(Field<?>... fields)
Restrict this aggregate function to FIRST values
An example:
MAX(ID) KEEP (DENSE_RANK LAST ORDER BY 1)
This clause is only available on
MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.
|
WindowBeforeOverStep<T> |
AggregateFunction.keepDenseRankLastOrderBy(SortField<?>... fields)
Restrict this aggregate function to FIRST values
An example:
MAX(ID) KEEP (DENSE_RANK LAST ORDER BY 1)
This clause is only available on
MIN, MAX, SUM, AVG, COUNT, VARIANCE, or STDDEV functions.
|
MergeValuesStep<R> |
MergeKeyStep.key(Collection<? extends Field<?>> keys)
Specify an optional KEY clause.
|
MergeValuesStep<R> |
MergeKeyStep.key(Field<?>... keys)
Specify an optional KEY clause.
|
WindowIgnoreNullsStep<T> |
Field.lag()
This method is part of the pre-2.0 API.
|
WindowIgnoreNullsStep<T> |
Field.lag(int offset)
This method is part of the pre-2.0 API.
|
WindowIgnoreNullsStep<T> |
Field.lag(int offset,
Field<T> defaultValue)
This method is part of the pre-2.0 API.
|
WindowIgnoreNullsStep<T> |
Field.lag(int offset,
T defaultValue)
This method is part of the pre-2.0 API.
|
BigInteger |
FactoryOperations.lastID()
Retrieve the last inserted ID.
|
WindowIgnoreNullsStep<T> |
Field.lastValue()
This method is part of the pre-2.0 API.
|
Condition |
Field.le(Field<T> field)
this <= field
|
Condition |
Field.le(Select<?> query)
this <= (Select
|
Condition |
Field.le(T value)
this <= value
|
WindowIgnoreNullsStep<T> |
Field.lead()
This method is part of the pre-2.0 API.
|
WindowIgnoreNullsStep<T> |
Field.lead(int offset)
This method is part of the pre-2.0 API.
|
WindowIgnoreNullsStep<T> |
Field.lead(int offset,
Field<T> defaultValue)
This method is part of the pre-2.0 API.
|
WindowIgnoreNullsStep<T> |
Field.lead(int offset,
T defaultValue)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.least(Field<?>... others)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.least(T... others)
This method is part of the pre-2.0 API.
|
TablePartitionByStep |
Table.leftOuterJoin(String sql)
LEFT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.leftOuterJoin(String sql)
Convenience method to LEFT OUTER JOIN a table to the last
table added to the FROM clause using
Table.leftOuterJoin(String)
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TablePartitionByStep |
Table.leftOuterJoin(String sql,
Object... bindings)
LEFT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.leftOuterJoin(String sql,
Object... bindings)
|
TablePartitionByStep |
Table.leftOuterJoin(String sql,
QueryPart... parts)
LEFT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.leftOuterJoin(String sql,
QueryPart... parts)
|
TablePartitionByStep |
Table.leftOuterJoin(TableLike<?> table)
LEFT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.leftOuterJoin(TableLike<?> table)
|
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)
|
Condition |
Field.lessOrEqualAll(Select<?> query)
this <= all (Select
|
Condition |
Field.lessOrEqualAll(T... array)
|
Condition |
Field.lessOrEqualAny(Field<T[]> array)
|
Condition |
Field.lessOrEqualAny(Select<?> query)
this <= any (Select
|
Condition |
Field.lessOrEqualAny(T... array)
|
Condition |
Field.lessOrEqualSome(Select<?> query)
|
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)
|
Condition |
Field.lessThanAll(Select<?> query)
this < all (Select
|
Condition |
Field.lessThanAll(T... array)
|
Condition |
Field.lessThanAny(Field<T[]> array)
|
Condition |
Field.lessThanAny(Select<?> query)
this < any (Select
|
Condition |
Field.lessThanAny(T... array)
|
Condition |
Field.lessThanSome(Select<?> query)
|
Condition |
Field.like(Field<String> value)
Create a condition to pattern-check this field against a value
SQL: this like value
|
Condition |
Field.like(Field<String> value,
char escape)
Create a condition to pattern-check this field against a value
SQL: this like value escape 'e'
|
Condition |
Field.like(String value)
Create a condition to pattern-check this field against a value
SQL: this like value
|
Condition |
Field.like(String value,
char escape)
Create a condition to pattern-check this field against a value
SQL: this like value escape 'e'
|
Condition |
Field.likeIgnoreCase(Field<String> field)
Create a condition to case-insensitively pattern-check this field against
a field
This translates to this ilike field in
SQLDialect.POSTGRES , or to
lower(this) like lower(field) in all other dialects.
|
Condition |
Field.likeIgnoreCase(Field<String> field,
char escape)
Create a condition to case-insensitively pattern-check this field against
a field
This translates to this ilike field in
SQLDialect.POSTGRES , or to
lower(this) like lower(field) in all other dialects.
|
Condition |
Field.likeIgnoreCase(String value)
Create a condition to case-insensitively pattern-check this field against
a value
This translates to this ilike value in
SQLDialect.POSTGRES , or to
lower(this) like lower(value) in all other dialects.
|
Condition |
Field.likeIgnoreCase(String value,
char escape)
Create a condition to case-insensitively pattern-check this field against
a value
This translates to this ilike value in
SQLDialect.POSTGRES , or to
lower(this) like lower(value) in all other dialects.
|
Condition |
Field.likeRegex(Field<String> pattern)
Create a condition to regex-pattern-check this field against a pattern
See Field.likeRegex(String) for more details
|
Condition |
Field.likeRegex(String pattern)
Create a condition to regex-pattern-check this field against a pattern
The SQL:2008 standard specifies a <regex like predicate>
of the following form:
<regex like predicate> ::=
<row value predicand> <regex like predicate part 2>
<regex like predicate part 2> ::=
[ NOT ] LIKE_REGEX <XQuery pattern> [ FLAG <XQuery option flag> ]
This particular LIKE_REGEX operator comes in several
flavours for various databases. jOOQ supports regular expressions as
follows:
SQL dialect
SQL syntax
Pattern syntax
Documentation
SQLDialect.ASE
-
-
-
SQLDialect.CUBRID
[search] REGEXP [pattern]
POSIX
http://www.cubrid.org/manual/841/en/REGEXP Conditional Expression
SQLDialect.DB2
-
-
-
SQLDialect.DERBY
-
-
-
SQLDialect.H2
[search] REGEXP [pattern]
Java
http
://www.h2database.com/html/grammar.html#condition_right_hand_side
SQLDialect.HSQLDB
REGEXP_MATCHES([search], [pattern])
Java
http://hsqldb.org/doc/guide/builtinfunctions-chapt.html#N13577
SQLDialect.INGRES
-
-
-
SQLDialect.MYSQL
[search] REGEXP [pattern]
POSIX
http://dev.mysql.com/doc/refman/5.6/en/regexp.html
SQLDialect.ORACLE
REGEXP_LIKE([search], [pattern])
POSIX
http://docs.oracle.com/cd/E14072_01/server.112/e10592/conditions007.htm#
sthref1994
SQLDialect.POSTGRES
[search] ~ [pattern]
POSIX
http://www.postgresql.org/docs/9.1/static/functions-matching.html#
FUNCTIONS-POSIX-REGEXP
SQLDialect.SQLITE
[search] REGEXP [pattern]
?
SimpleSelectOffsetStep<R> |
SimpleSelectLimitStep.limit(int numberOfRows)
Add a LIMIT clause to the query
If there is no LIMIT or TOP clause in your
RDBMS, this may be simulated with a ROW_NUMBER() window function
and nested SELECT statements.
|
SelectOffsetStep |
SelectLimitStep.limit(int numberOfRows)
Add a LIMIT clause to the query
If there is no LIMIT or TOP clause in your
RDBMS, this may be simulated with a ROW_NUMBER() window
function and nested SELECT statements.
|
SimpleSelectForUpdateStep<R> |
SimpleSelectLimitStep.limit(int offset,
int numberOfRows)
Add a LIMIT clause to the query
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SelectForUpdateStep |
SelectLimitStep.limit(int offset,
int numberOfRows)
Add a LIMIT clause to the query
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SimpleSelectForUpdateStep<R> |
SimpleSelectLimitStep.limit(int offset,
Param<Integer> numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SelectForUpdateStep |
SelectLimitStep.limit(int offset,
Param<Integer> numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SimpleSelectOffsetStep<R> |
SimpleSelectLimitStep.limit(Param<Integer> numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SelectOffsetStep |
SelectLimitStep.limit(Param<Integer> numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SimpleSelectForUpdateStep<R> |
SimpleSelectLimitStep.limit(Param<Integer> offset,
int numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SelectForUpdateStep |
SelectLimitStep.limit(Param<Integer> offset,
int numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SimpleSelectForUpdateStep<R> |
SimpleSelectLimitStep.limit(Param<Integer> offset,
Param<Integer> numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
SelectForUpdateStep |
SelectLimitStep.limit(Param<Integer> offset,
Param<Integer> numberOfRows)
Add a LIMIT clause to the query using named parameters
Note that some dialects do not support bind values at all in
LIMIT or TOP clauses!
|
Field<BigDecimal> |
Field.ln()
This method is part of the pre-2.0 API.
|
LoaderCSVStep<R> |
LoaderSourceStep.loadCSV(File file)
Load CSV data
|
LoaderCSVStep<R> |
LoaderSourceStep.loadCSV(InputStream stream)
Load CSV data
|
LoaderCSVStep<R> |
LoaderSourceStep.loadCSV(Reader reader)
Load CSV data
|
LoaderCSVStep<R> |
LoaderSourceStep.loadCSV(String data)
Load CSV data
|
<R extends TableRecord<R>> LoaderOptionsStep<R> |
FactoryOperations.loadInto(Table<R> table)
Create a new Loader object to load data from a CSV or XML
source
|
LoaderXMLStep<R> |
LoaderSourceStep.loadXML(File file)
Load XML data
|
LoaderXMLStep<R> |
LoaderSourceStep.loadXML(InputSource source)
Load XML data
|
LoaderXMLStep<R> |
LoaderSourceStep.loadXML(InputStream stream)
Load XML data
|
LoaderXMLStep<R> |
LoaderSourceStep.loadXML(Reader reader)
Load XML data
|
LoaderXMLStep<R> |
LoaderSourceStep.loadXML(String data)
Load XML data
|
Field<BigDecimal> |
Field.log(int base)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lower()
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(Field<? extends Number> length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(Field<? extends Number> length,
Field<String> character)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(int length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(int length,
char character)
This method is part of the pre-2.0 API.
|
Condition |
Field.lt(Field<T> field)
this < field
|
Condition |
Field.lt(Select<?> query)
this < (Select
|
Condition |
Field.lt(T value)
this < value
|
Field<String> |
Field.ltrim()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.max()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<T> |
Field.maxOver()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.median()
This method is part of the pre-2.0 API.
|
<R extends Record> MergeUsingStep<R> |
FactoryOperations.mergeInto(Table<R> table)
Create a new DSL SQL standard MERGE statement.
|
<R extends Record> MergeKeyStep<R> |
FactoryOperations.mergeInto(Table<R> table,
Collection<? extends Field<?>> fields)
Create a new DSL merge statement (H2-specific syntax)
|
<R extends Record> MergeKeyStep<R> |
FactoryOperations.mergeInto(Table<R> table,
Field<?>... fields)
Create a new DSL merge statement (H2-specific syntax)
This statement is available from DSL syntax only.
|
Field<T> |
Field.min()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<T> |
Field.minOver()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.mod(Field<? extends Number> value)
An arithmetic expression getting the modulo of this divided by value
This renders the modulo operation where available:
[this] % [value]
... or the modulo function elsewhere:
mod([this], [value])
|
Field<T> |
Field.mod(Number value)
An arithmetic expression getting the modulo of this divided by value
This renders the modulo operation where available:
[this] % [value]
... or the modulo function elsewhere:
mod([this], [value])
|
Field<T> |
Field.mul(Field<? extends Number> value)
An arithmetic expression multiplying this with value
If this is a numeric field, then the result is a number of the same
type as this field.
|
Field<T> |
Field.mul(Number value)
An arithmetic expression multiplying this with value
If this is a numeric field, then the result is a number of the same
type as this field.
|
Table<Record> |
Table.naturalJoin(String sql)
NATURAL JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalJoin(String sql)
Convenience method to NATURAL JOIN a table to the last table
added to the FROM clause using
Table.naturalJoin(String)
Natural joins are supported by most RDBMS.
|
Table<Record> |
Table.naturalJoin(String sql,
Object... bindings)
NATURAL JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalJoin(String sql,
Object... bindings)
|
Table<Record> |
Table.naturalJoin(String sql,
QueryPart... parts)
NATURAL JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalJoin(String sql,
QueryPart... parts)
|
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)
|
Table<Record> |
Table.naturalLeftOuterJoin(String sql,
QueryPart... parts)
NATURAL LEFT OUTER JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalLeftOuterJoin(String sql,
QueryPart... parts)
|
Table<Record> |
Table.naturalLeftOuterJoin(TableLike<?> table)
NATURAL LEFT OUTER JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalLeftOuterJoin(TableLike<?> table)
|
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)
|
Table<Record> |
Table.naturalRightOuterJoin(String sql,
QueryPart... parts)
NATURAL RIGHT OUTER JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalRightOuterJoin(String sql,
QueryPart... parts)
|
Table<Record> |
Table.naturalRightOuterJoin(TableLike<?> table)
NATURAL RIGHT OUTER JOIN a table to this table.
|
SelectJoinStep |
SelectJoinStep.naturalRightOuterJoin(TableLike<?> table)
|
Condition |
RowN.ne(Field<?>... values)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Field.ne(Field<T> field)
this !
|
Condition |
Row1.ne(Field<T1> t1)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row2.ne(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row3.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row4.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row5.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row6.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row7.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row8.ne(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
RowN.ne(Object... values)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row1.ne(Row1<T1> row)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row2.ne(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row3.ne(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row4.ne(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row5.ne(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row6.ne(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row7.ne(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row8.ne(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
RowN.ne(RowN row)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Field.ne(Select<?> query)
this !
|
Condition |
Field.ne(T value)
this !
|
Condition |
Row1.ne(T1 t1)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row2.ne(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row3.ne(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row4.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row5.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row6.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row7.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row8.ne(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Field<T> |
Field.neg()
Negate this field to get its negative value.
|
InsertSetStep<R> |
InsertSetMoreStep.newRecord()
Add an additional record to the INSERT statement
|
void |
InsertQuery.newRecord()
Adds a new Record to the insert statement for multi-record inserts
Calling this method will cause subsequent calls to
StoreQuery.addValue(Field, Object) (and similar) to fill the next record.
|
Field<T> |
Sequence.nextval()
Increment the sequence and get the next value
|
<T extends Number> T |
FactoryOperations.nextval(Sequence<T> sequence)
Convenience method to fetch the NEXTVAL for a sequence directly from this
Factory 's underlying JDBC Connection
|
Condition |
Condition.not()
|
BetweenAndStep<T> |
Field.notBetween(Field<T> minValue)
Create a condition to check this field against some bounds
SQL: this not between minValue and maxValue
|
Condition |
Field.notBetween(Field<T> minValue,
Field<T> maxValue)
Create a condition to check this field against some bounds
This is the same as calling
notBetween(minValue).and(maxValue)
SQL: this not between minValue and maxValue
|
BetweenAndStep<T> |
Field.notBetween(T minValue)
Create a condition to check this field against some bounds
SQL: this not between minValue and maxValue
|
Condition |
Field.notBetween(T minValue,
T maxValue)
Create a condition to check this field against some bounds
This is the same as calling
notBetween(minValue).and(maxValue)
SQL: this not between minValue and maxValue
|
BetweenAndStep<T> |
Field.notBetweenSymmetric(Field<T> minValue)
Create a condition to check this field against some bounds
SQL: this not between symmetric minValue and maxValue
|
Condition |
Field.notBetweenSymmetric(Field<T> minValue,
Field<T> maxValue)
Create a condition to check this field against some bounds
This is the same as calling
notBetweenSymmetric(minValue).and(maxValue)
SQL: this not between symmetric minValue and maxValue
|
BetweenAndStep<T> |
Field.notBetweenSymmetric(T minValue)
Create a condition to check this field against some bounds
SQL: this not between symmetric minValue and maxValue
|
Condition |
Field.notBetweenSymmetric(T minValue,
T maxValue)
Create a condition to check this field against some bounds
This is the same as calling
notBetweenSymmetric(minValue).and(maxValue)
SQL: this not between symmetric minValue and maxValue
|
Condition |
RowN.notEqual(Field<?>... values)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Field.notEqual(Field<T> field)
this !
|
Condition |
Row1.notEqual(Field<T1> t1)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row2.notEqual(Field<T1> t1,
Field<T2> t2)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row3.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row4.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row5.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row6.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row7.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row8.notEqual(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
RowN.notEqual(Object... values)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row1.notEqual(Row1<T1> row)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row2.notEqual(Row2<T1,T2> row)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row3.notEqual(Row3<T1,T2,T3> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row4.notEqual(Row4<T1,T2,T3,T4> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row5.notEqual(Row5<T1,T2,T3,T4,T5> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row6.notEqual(Row6<T1,T2,T3,T4,T5,T6> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row7.notEqual(Row7<T1,T2,T3,T4,T5,T6,T7> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row8.notEqual(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
RowN.notEqual(RowN row)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Field.notEqual(Select<?> query)
this !
|
Condition |
Field.notEqual(T value)
this !
|
Condition |
Row1.notEqual(T1 t1)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row2.notEqual(T1 t1,
T2 t2)
Compare this row value expression with another row value expression for
non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row3.notEqual(T1 t1,
T2 t2,
T3 t3)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row4.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row5.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row6.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row7.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Row8.notEqual(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Compare this row value expression with another row value expression for non-equality
Row non-equality comparison predicates can be simulated in those
databases that do not support such predicates natively:
(A, B) <> (1, 2) is equivalent to
NOT(A = 1 AND B = 2)
|
Condition |
Field.notEqualAll(Field<T[]> array)
this !
|
Condition |
Field.notEqualAll(Select<?> query)
this !
|
Condition |
Field.notEqualAll(T... array)
this !
|
Condition |
Field.notEqualAny(Field<T[]> array)
this !
|
Condition |
Field.notEqualAny(Select<?> query)
this !
|
Condition |
Field.notEqualAny(T... array)
this !
|
Condition |
Field.notEqualIgnoreCase(Field<String> value)
lower(this) !
|
Condition |
Field.notEqualIgnoreCase(String value)
lower(this) !
|
Condition |
Field.notEqualSome(Select<?> query)
|
Condition |
Row1.notIn(Collection<? extends Row1<T1>> row)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row2.notIn(Collection<? extends Row2<T1,T2>> rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row3.notIn(Collection<? extends Row3<T1,T2,T3>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row4.notIn(Collection<? extends Row4<T1,T2,T3,T4>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row5.notIn(Collection<? extends Row5<T1,T2,T3,T4,T5>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row6.notIn(Collection<? extends Row6<T1,T2,T3,T4,T5,T6>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row7.notIn(Collection<? extends Row7<T1,T2,T3,T4,T5,T6,T7>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row8.notIn(Collection<? extends Row8<T1,T2,T3,T4,T5,T6,T7,T8>> rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
RowN.notIn(Collection<? extends RowN> rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Field.notIn(Collection<T> values)
Create a condition to check this field against several values
Note that if any of the passed values is NULL , then the
condition will be NULL (or false , depending on
the dialect) as well.
|
Condition |
Field.notIn(Field<?>... values)
Create a condition to check this field against several values
Note that if any of the passed values is NULL , then the
condition will be NULL (or false , depending on
the dialect) as well.
|
Condition |
Row1.notIn(Row1<T1>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row2.notIn(Row2<T1,T2>... rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row3.notIn(Row3<T1,T2,T3>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row4.notIn(Row4<T1,T2,T3,T4>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row5.notIn(Row5<T1,T2,T3,T4,T5>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row6.notIn(Row6<T1,T2,T3,T4,T5,T6>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row7.notIn(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row8.notIn(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)
Compare this row value expression with a set of row value expressions for equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
RowN.notIn(RowN... rows)
Compare this row value expression with a set of row value expressions for
equality
Row NOT IN predicates can be simulated in those databases that do not
support such predicates natively:
(A, B) NOT IN ((1, 2), (3, 4)) is equivalent to
NOT(((A, B) = (1, 2)) OR ((A, B) = (3, 4))) , which is
equivalent to NOT((A = 1 AND B = 2) OR (A = 3 AND B = 4))
|
Condition |
Row.notIn(Select<?> select)
Compare this row value expression with a subselect for non-equality
Note that the subquery must return a table of the same degree as this row
value expression.
|
Condition |
Field.notIn(Select<?> query)
Create a condition to check this field against a subquery
Note that the subquery must return exactly one field.
|
Condition |
Field.notIn(T... values)
Create a condition to check this field against several values
Note that if any of the passed values is NULL , then the
condition will be NULL (or false , depending on
the dialect) as well.
|
Condition |
Field.notLike(Field<String> field)
Create a condition to pattern-check this field against a field
SQL: this not like field
|
Condition |
Field.notLike(Field<String> field,
char escape)
Create a condition to pattern-check this field against a field
SQL: this not like field escape 'e'
|
Condition |
Field.notLike(String value)
Create a condition to pattern-check this field against a value
SQL: this not like value
|
Condition |
Field.notLike(String value,
char escape)
Create a condition to pattern-check this field against a value
SQL: this not like value escape 'e'
|
Condition |
Field.notLikeIgnoreCase(Field<String> field)
Create a condition to case-insensitively pattern-check this field against
a field
This translates to this not ilike field in
SQLDialect.POSTGRES , or to
lower(this) not like lower(field) in all other dialects.
|
Condition |
Field.notLikeIgnoreCase(Field<String> field,
char escape)
Create a condition to case-insensitively pattern-check this field against
a field
This translates to this not ilike field in
SQLDialect.POSTGRES , or to
lower(this) not like lower(field) in all other dialects.
|
Condition |
Field.notLikeIgnoreCase(String value)
Create a condition to case-insensitively pattern-check this field against
a value
This translates to this not ilike value in
SQLDialect.POSTGRES , or to
lower(this) not like lower(value) in all other dialects.
|
Condition |
Field.notLikeIgnoreCase(String value,
char escape)
Create a condition to case-insensitively pattern-check this field against
a value
This translates to this not ilike value in
SQLDialect.POSTGRES , or to
lower(this) not like lower(value) in all other dialects.
|
Condition |
Field.notLikeRegex(Field<String> pattern)
Create a condition to regex-pattern-check this field against a pattern
See Field.likeRegex(String) for more details
|
Condition |
Field.notLikeRegex(String pattern)
Create a condition to regex-pattern-check this field against a pattern
See Field.likeRegex(String) for more details
|
SimpleSelectFinalStep<R> |
SimpleSelectForUpdateWaitStep.noWait()
Add a WAIT clause to the FOR UPDATE clause at
the end of the query.
|
SelectFinalStep |
SelectForUpdateWaitStep.noWait()
Add a WAIT clause to the FOR UPDATE clause at
the end of the query.
|
Field<T> |
Field.nullif(Field<T> other)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.nullif(T other)
This method is part of the pre-2.0 API.
|
SortField<T> |
SortField.nullsFirst()
Add a NULLS FIRST clause to this sort field
|
SortField<T> |
SortField.nullsLast()
Add a NULLS LAST clause to this sort field
|
LoaderCSVOptionsStep<R> |
LoaderCSVOptionsStep.nullString(String nullString)
Specify the input string representation of NULL .
|
Field<T> |
Field.nvl(Field<T> defaultValue)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.nvl(T defaultValue)
This method is part of the pre-2.0 API.
|
<Z> Field<Z> |
Field.nvl2(Field<Z> valueIfNotNull,
Field<Z> valueIfNull)
This method is part of the pre-2.0 API.
|
<Z> Field<Z> |
Field.nvl2(Z valueIfNotNull,
Z valueIfNull)
This method is part of the pre-2.0 API.
|
Field<Integer> |
Field.octetLength()
This method is part of the pre-2.0 API.
|
SimpleSelectForUpdateWaitStep<R> |
SimpleSelectForUpdateOfStep.of(Collection<Field<?>> fields)
Add an OF clause to the FOR UPDATE clause at
the end of the query.
|
SelectForUpdateWaitStep |
SelectForUpdateOfStep.of(Collection<Field<?>> fields)
Add an OF clause to the FOR UPDATE clause at
the end of the query.
|
SimpleSelectForUpdateWaitStep<R> |
SimpleSelectForUpdateOfStep.of(Field<?>... fields)
Add an OF clause to the FOR UPDATE clause at
the end of the query.
|
SelectForUpdateWaitStep |
SelectForUpdateOfStep.of(Field<?>... fields)
Add an OF clause to the FOR UPDATE clause at
the end of the query.
|
SimpleSelectForUpdateWaitStep<R> |
SimpleSelectForUpdateOfStep.of(Table<?>... tables)
Add an OF clause to the FOR UPDATE clause at
the end of the query.
|
SelectForUpdateWaitStep |
SelectForUpdateOfStep.of(Table<?>... tables)
Add an OF clause to the FOR UPDATE clause at
the end of the query.
|
SimpleSelectForUpdateStep<R> |
SimpleSelectOffsetStep.offset(int offset)
Add an OFFSET clause to the query
If there is no LIMIT ..
|
SelectForUpdateStep |
SelectOffsetStep.offset(int offset)
Add an OFFSET clause to the query
If there is no LIMIT ..
|
SimpleSelectForUpdateStep<R> |
SimpleSelectOffsetStep.offset(Param<Integer> offset)
Add an OFFSET clause to the query using a named parameter
If there is no LIMIT ..
|
SelectForUpdateStep |
SelectOffsetStep.offset(Param<Integer> offset)
Add an OFFSET clause to the query using a named parameter
If there is no LIMIT ..
|
TableOnConditionStep |
TableOnStep.on(Condition... conditions)
Add an ON clause to the JOIN
|
SelectOnConditionStep |
SelectOnStep.on(Condition... conditions)
Add an ON clause to the previous JOIN
|
MergeOnConditionStep<R> |
MergeOnStep.on(Condition... conditions)
Provide join conditions and proceed to the next step
|
DivideByOnConditionStep |
DivideByOnStep.on(Condition... conditions)
Add a division condition to the DIVIDE BY clause
|
<T> PivotInStep<T> |
PivotForStep.on(Field<T> field)
Add a list of fields to the PIVOT clause.
|
TableOnConditionStep |
TableOnStep.on(String sql)
Add an ON clause to the JOIN
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectOnConditionStep |
SelectOnStep.on(String sql)
Add an ON clause to the previous JOIN
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
MergeOnConditionStep<R> |
MergeOnStep.on(String sql)
Provide join conditions and proceed to the next step
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
DivideByOnConditionStep |
DivideByOnStep.on(String sql)
Add a division condition to the DIVIDE BY clause
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnStep.on(String sql,
Object... bindings)
Add an ON clause to the JOIN
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectOnConditionStep |
SelectOnStep.on(String sql,
Object... bindings)
Add an ON clause to the previous JOIN
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
MergeOnConditionStep<R> |
MergeOnStep.on(String sql,
Object... bindings)
Provide join conditions and proceed to the next step
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
DivideByOnConditionStep |
DivideByOnStep.on(String sql,
Object... bindings)
Add a division condition to the DIVIDE BY clause
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnStep.on(String sql,
QueryPart... parts)
Add an ON clause to the JOIN
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectOnConditionStep |
SelectOnStep.on(String sql,
QueryPart... parts)
Add an ON clause to the previous JOIN
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
MergeOnConditionStep<R> |
MergeOnStep.on(String sql,
QueryPart... parts)
Provide join conditions and proceed to the next step
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
DivideByOnConditionStep |
DivideByOnStep.on(String sql,
QueryPart... parts)
Add a division condition to the DIVIDE BY clause
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.onDuplicateKeyError()
Instruct the Loader to cause an error in loading if there
are any duplicate records.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.onDuplicateKeyIgnore()
Instruct the Loader to skip duplicate records if the main
unique key's value is already in the database.
|
InsertFinalStep<R> |
InsertOnDuplicateStep.onDuplicateKeyIgnore()
Add an ON DUPLICATE KEY IGNORE clause to this insert query.
|
void |
InsertQuery.onDuplicateKeyIgnore(boolean flag)
Whether an ON DUPLICATE KEY IGNORE clause should be added to
this INSERT statement.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.onDuplicateKeyUpdate()
Instruct the Loader to update duplicate records if the main
unique key's value is already in the database.
|
InsertOnDuplicateSetStep<R> |
InsertOnDuplicateStep.onDuplicateKeyUpdate()
Add an ON DUPLICATE KEY UPDATE clause to this insert query.
|
void |
InsertQuery.onDuplicateKeyUpdate(boolean flag)
Whether a ON DUPLICATE KEY UPDATE clause should be added to
this INSERT statement.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.onErrorAbort()
Instruct the Loader to abort loading after the first error
that might occur when inserting a record.
|
LoaderOptionsStep<R> |
LoaderOptionsStep.onErrorIgnore()
Instruct the Loader to ignore any errors that might occur
when inserting a record.
|
TableOnConditionStep |
TableOnStep.onKey()
Join the table on a non-ambiguous foreign key relationship between the
two joined tables.
|
SelectJoinStep |
SelectOnStep.onKey()
Join the previous table on a non-ambiguous foreign key relationship
between the two joined tables.
|
TableOnConditionStep |
TableOnStep.onKey(ForeignKey<?,?> key)
Join the table on a non-ambiguous foreign key relationship between the
two joined tables.
|
SelectJoinStep |
SelectOnStep.onKey(ForeignKey<?,?> key)
Join the table on a non-ambiguous foreign key relationship between the
two joined tables.
|
TableOnConditionStep |
TableOnStep.onKey(TableField<?,?>... keyFields)
Join the table on a non-ambiguous foreign key relationship between the
two joined tables.
|
SelectJoinStep |
SelectOnStep.onKey(TableField<?,?>... keyFields)
Join the previous table on a non-ambiguous foreign key relationship
between the two joined tables.
|
UpdateConditionStep<R> |
UpdateConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator
|
TableOnConditionStep |
TableOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.or(Condition condition)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
Condition |
Condition.or(Condition other)
Combine this condition with another one using the Operator.OR
operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.or(String sql)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
Condition |
Condition.or(String sql)
Combine this condition with another one using the Operator.OR
operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.or(String sql,
Object... bindings)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
Condition |
Condition.or(String sql,
Object... bindings)
Combine this condition with another one using the Operator.OR
operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TableOnConditionStep |
TableOnConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.or(String sql,
QueryPart... parts)
Combine the currently assembled conditions with another one using the
Operator.OR operator.
|
Condition |
Condition.or(String sql,
QueryPart... parts)
Combine this condition with another one using the Operator.OR
operator.
|
WindowRowsStep<T> |
WindowOrderByStep.orderBy(Collection<SortField<?>> fields)
Add an ORDER BY clause to the window function.
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderBy(Collection<SortField<?>> fields)
Add an ORDER BY clause to the query
|
SelectLimitStep |
SelectOrderByStep.orderBy(Collection<SortField<?>> fields)
Add an ORDER BY clause to the query
|
GroupConcatSeparatorStep |
GroupConcatOrderByStep.orderBy(Collection<SortField<?>> fields)
Add an ORDER BY clause to the query
|
WindowRowsStep<T> |
WindowOrderByStep.orderBy(Field<?>... fields)
Add an ORDER BY clause to the window function.
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderBy(Field<?>... fields)
Add an ORDER BY clause to the query
|
SelectLimitStep |
SelectOrderByStep.orderBy(Field<?>... fields)
Add an ORDER BY clause to the query
|
GroupConcatSeparatorStep |
GroupConcatOrderByStep.orderBy(Field<?>... fields)
Add an ORDER BY clause to the query
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderBy(int... fieldIndexes)
Add an ORDER BY clause to the query
Indexes start at 1 in SQL!
|
SelectLimitStep |
SelectOrderByStep.orderBy(int... fieldIndexes)
Add an ORDER BY clause to the query
Indexes start at 1 in SQL!
|
WindowRowsStep<T> |
WindowOrderByStep.orderBy(SortField<?>... fields)
Add an ORDER BY clause to the window function.
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderBy(SortField<?>... fields)
Add an ORDER BY clause to the query
|
SelectLimitStep |
SelectOrderByStep.orderBy(SortField<?>... fields)
Add an ORDER BY clause to the query
|
GroupConcatSeparatorStep |
GroupConcatOrderByStep.orderBy(SortField<?>... fields)
Add an ORDER BY clause to the query
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderSiblingsBy(Collection<SortField<?>> fields)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SelectLimitStep |
SelectOrderByStep.orderSiblingsBy(Collection<SortField<?>> fields)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderSiblingsBy(Field<?>... fields)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SelectLimitStep |
SelectOrderByStep.orderSiblingsBy(Field<?>... fields)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderSiblingsBy(int... fieldIndexes)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SelectLimitStep |
SelectOrderByStep.orderSiblingsBy(int... fieldIndexes)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SimpleSelectLimitStep<R> |
SimpleSelectOrderByStep.orderSiblingsBy(SortField<?>... fields)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
SelectLimitStep |
SelectOrderByStep.orderSiblingsBy(SortField<?>... fields)
Add an ORDER SIBLINGS BY clause to the query
This clause can be used only along with Oracle's CONNECT BY
clause, to indicate that the hierarchical ordering should be preserved
and elements of each hierarchy should be ordered among themselves.
|
UpdateConditionStep<R> |
UpdateConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.OR operator
|
TableOnConditionStep |
TableOnConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS
clause using the Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.orExists(Select<?> select)
Combine the currently assembled conditions with an EXISTS
clause using the Operator.OR operator.
|
Condition |
Condition.orExists(Select<?> select)
Combine this condition with an EXISTS clause using the
Operator.OR operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator
|
TableOnConditionStep |
TableOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.orNot(Condition condition)
Combine the currently assembled conditions with a negated other one using
the Operator.OR operator.
|
Condition |
Condition.orNot(Condition other)
Combine this condition with a negated other one using the
Operator.OR operator.
|
UpdateConditionStep<R> |
UpdateConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.OR operator
|
TableOnConditionStep |
TableOnConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS
clause using the Operator.OR operator.
|
SimpleSelectConditionStep<R> |
SimpleSelectConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
SelectOnConditionStep |
SelectOnConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
SelectHavingConditionStep |
SelectHavingConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
SelectConditionStep |
SelectConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
MergeOnConditionStep<R> |
MergeOnConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS clause using
the Operator.OR operator and proceed to the next step.
|
DivideByOnConditionStep |
DivideByOnConditionStep.orNotExists(Select<?> select)
Combine the currently assembled conditions with a NOT EXISTS
clause using the Operator.OR operator.
|
Condition |
Condition.orNotExists(Select<?> select)
Combine this condition with a NOT EXIST clause using the
Operator.OR operator.
|
Field<T> |
CaseWhenStep.otherwise(Field<T> result)
Add an else clause to the already constructed case statement
|
Field<T> |
CaseConditionStep.otherwise(Field<T> result)
Add an else clause to the already constructed case statement
|
Field<T> |
CaseWhenStep.otherwise(T result)
Add an else clause to the already constructed case statement
|
Field<T> |
CaseConditionStep.otherwise(T result)
Add an else clause to the already constructed case statement
|
WindowPartitionByStep<T> |
WindowOverStep.over()
Add an OVER clause
|
WindowPartitionByStep<T> |
WindowBeforeOverStep.over()
Add an OVER clause
|
WindowPartitionByStep<T> |
AggregateFunction.over()
Turn this aggregate function into a window function.
|
Condition |
Row2.overlaps(Field<T1> t1,
Field<T2> t2)
Check if this row value expression overlaps another row value expression
The SQL standard specifies a temporal OVERLAPS predicate,
which comes in two flavours:
(DATE, DATE) OVERLAPS (DATE, DATE)
(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)
jOOQ also supports arbitrary 2-degree row value expression comparisons,
by simulating them as such
-- This predicate
(A, B) OVERLAPS (C, D)
-- can be simulated as such
(C <= B) AND (A <= D)
|
Condition |
Row2.overlaps(Row2<T1,T2> row)
Check if this row value expression overlaps another row value expression
The SQL standard specifies a temporal OVERLAPS predicate,
which comes in two flavours:
(DATE, DATE) OVERLAPS (DATE, DATE)
(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)
jOOQ also supports arbitrary 2-degree row value expression comparisons,
by simulating them as such
-- This predicate
(A, B) OVERLAPS (C, D)
-- can be simulated as such
(C <= B) AND (A <= D)
|
Condition |
Row2.overlaps(T1 t1,
T2 t2)
Check if this row value expression overlaps another row value expression
The SQL standard specifies a temporal OVERLAPS predicate,
which comes in two flavours:
(DATE, DATE) OVERLAPS (DATE, DATE)
(DATE, INTERVAL) OVERLAPS (DATE, INTERVAL)
jOOQ also supports arbitrary 2-degree row value expression comparisons,
by simulating them as such
-- This predicate
(A, B) OVERLAPS (C, D)
-- can be simulated as such
(C <= B) AND (A <= D)
|
TableOnStep |
TablePartitionByStep.partitionBy(Collection<? extends Field<?>> fields)
Add a PARTITION BY clause to the right hand side of the
OUTER JOIN keywords
|
SelectOnStep |
SelectJoinPartitionByStep.partitionBy(Collection<? extends Field<?>> fields)
Add a PARTITION BY clause to the right hand side of the
OUTER JOIN keywords
|
WindowOrderByStep<T> |
WindowPartitionByStep.partitionBy(Field<?>... fields)
Add a PARTITION BY clause to the window functions.
|
TableOnStep |
TablePartitionByStep.partitionBy(Field<?>... fields)
Add a PARTITION BY clause to the right hand side of the
OUTER JOIN keywords
|
SelectOnStep |
SelectJoinPartitionByStep.partitionBy(Field<?>... fields)
Add a PARTITION BY clause to the right hand side of the
OUTER JOIN keywords
|
WindowOrderByStep<T> |
WindowPartitionByStep.partitionByOne()
Add a PARTITION BY 1 clause to the window functions, where
such a clause is required by the syntax of an RDBMS.
|
PivotForStep |
Table.pivot(Collection<? extends Field<?>> aggregateFunctions)
Create a new TABLE reference from this table, pivoting it
into another form
For more details, see Table.pivot(Field...)
|
PivotForStep |
Table.pivot(Field<?>... aggregateFunctions)
Create a new TABLE reference from this table, pivoting it
into another form
This has been observed to work with
SQLDialect.ORACLE
SQLDialect.SQLSERVER (not yet officially supported)
Other dialects by using some means of simulation (not yet officially
supported)
|
Field<Integer> |
Field.position(Field<String> search)
This method is part of the pre-2.0 API.
|
Field<Integer> |
Field.position(String search)
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.power(Number exponent)
This method is part of the pre-2.0 API.
|
Query |
FactoryOperations.query(String sql)
Create a new query holding plain SQL.
|
Query |
FactoryOperations.query(String sql,
Object... bindings)
Create a new query holding plain SQL.
|
Query |
FactoryOperations.query(String sql,
QueryPart... parts)
Create a new query holding plain SQL.
|
LoaderCSVOptionsStep<R> |
LoaderCSVOptionsStep.quote(char quote)
Specify the quote character.
|
Field<BigDecimal> |
Field.rad()
This method is part of the pre-2.0 API.
|
Field<String> |
Field.repeat(Field<? extends Number> count)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.repeat(Number count)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.replace(Field<String> search)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.replace(Field<String> search,
Field<String> replace)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.replace(String search)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.replace(String search,
String replace)
This method is part of the pre-2.0 API.
|
WindowOverStep<T> |
WindowIgnoreNullsStep.respectNulls()
Add a RESPECT NULLS clause to the window function.
|
ResultQuery<Record> |
FactoryOperations.resultQuery(String sql)
Create a new query holding plain SQL.
|
ResultQuery<Record> |
FactoryOperations.resultQuery(String sql,
Object... bindings)
Create a new query holding plain SQL.
|
ResultQuery<Record> |
FactoryOperations.resultQuery(String sql,
QueryPart... parts)
Create a new query holding plain SQL.
|
InsertResultStep<R> |
InsertReturningStep.returning()
Configure the INSERT statement to return all fields in
R .
|
InsertResultStep<R> |
InsertReturningStep.returning(Collection<? extends Field<?>> fields)
Configure the INSERT statement to return a list of fields in
R .
|
Table<Record> |
DivideByReturningStep.returning(Collection<? extends Field<?>> fields)
Specify the fields that you want the division to return from the dividend
|
InsertResultStep<R> |
InsertReturningStep.returning(Field<?>... fields)
Configure the INSERT statement to return a list of fields in
R .
|
Table<Record> |
DivideByReturningStep.returning(Field<?>... fields)
Specify the fields that you want the division to return from the dividend
|
TablePartitionByStep |
Table.rightOuterJoin(String sql)
RIGHT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.rightOuterJoin(String sql)
Convenience method to RIGHT OUTER JOIN a table to the last
table added to the FROM clause using
Table.rightOuterJoin(String)
This is only possible where the underlying RDBMS supports it
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
TablePartitionByStep |
Table.rightOuterJoin(String sql,
Object... bindings)
RIGHT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.rightOuterJoin(String sql,
Object... bindings)
|
TablePartitionByStep |
Table.rightOuterJoin(String sql,
QueryPart... parts)
RIGHT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.rightOuterJoin(String sql,
QueryPart... parts)
|
TablePartitionByStep |
Table.rightOuterJoin(TableLike<?> table)
RIGHT OUTER JOIN a table to this table.
|
SelectJoinPartitionByStep |
SelectJoinStep.rightOuterJoin(TableLike<?> table)
Convenience method to RIGHT OUTER JOIN a table to the last
table added to the FROM clause using
Table.rightOuterJoin(TableLike)
This is only possible where the underlying RDBMS supports it
|
Field<T> |
Field.round()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.round(int decimals)
This method is part of the pre-2.0 API.
|
WindowRowsAndStep<T> |
WindowRowsStep.rowsBetweenCurrentRow()
Add a ROWS BETWEEN CURRENT ROW ...
|
WindowRowsAndStep<T> |
WindowRowsStep.rowsBetweenFollowing(int number)
Add a ROWS BETWEEN [number] FOLLOWING ...
|
WindowRowsAndStep<T> |
WindowRowsStep.rowsBetweenPreceding(int number)
Add a ROWS BETWEEN [number] PRECEDING ...
|
WindowRowsAndStep<T> |
WindowRowsStep.rowsBetweenUnboundedFollowing()
Add a ROWS BETWEEN UNBOUNDED FOLLOWING ...
|
WindowRowsAndStep<T> |
WindowRowsStep.rowsBetweenUnboundedPreceding()
Add a ROWS BETWEEN UNBOUNDED PRECEDING ...
|
WindowFinalStep<T> |
WindowRowsStep.rowsCurrentRow()
Add a ROWS CURRENT ROW frame clause to the window function.
|
WindowFinalStep<T> |
WindowRowsStep.rowsFollowing(int number)
Add a ROWS [number] FOLLOWING frame clause to the window
function.
|
WindowFinalStep<T> |
WindowRowsStep.rowsPreceding(int number)
Add a ROWS [number] PRECEDING frame clause to the window
function.
|
WindowFinalStep<T> |
WindowRowsStep.rowsUnboundedFollowing()
Add a ROWS UNBOUNDED FOLLOWING frame clause to the window
function.
|
WindowFinalStep<T> |
WindowRowsStep.rowsUnboundedPreceding()
Add a ROWS UNBOUNDED PRECEDING frame clause to the window
function.
|
Field<String> |
Field.rpad(Field<? extends Number> length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.rpad(Field<? extends Number> length,
Field<String> character)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.rpad(int length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.rpad(int length,
char character)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.rtrim()
This method is part of the pre-2.0 API.
|
SelectSelectStep |
SelectSelectStep.select(Collection<? extends Field<?>> fields)
Add additional fields to the SELECT clause of this query
|
SelectSelectStep |
FactoryOperations.select(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
SelectSelectStep |
SelectSelectStep.select(Field<?>... fields)
Add additional fields to the SELECT clause of this query
|
SelectSelectStep |
FactoryOperations.select(Field<?>... fields)
Create a new DSL select statement.
|
Merge<R> |
MergeValuesStep.select(Select<?> select)
Use a SELECT statement as the source of values for the
MERGE statement
This variant of the MERGE ..
|
Insert<R> |
InsertValuesStep.select(Select<?> select)
Use a SELECT statement as the source of values for the
INSERT statement
This variant of the INSERT ..
|
Insert<R> |
InsertSetStep.select(Select<?> select)
Use a SELECT statement as the source of values for the
INSERT statement
This variant of the INSERT ..
|
SelectSelectStep |
FactoryOperations.selectCount()
Create a new DSL select statement for COUNT(*)
Example:
Factory create = new Factory();
create.selectCount()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
|
SelectSelectStep |
FactoryOperations.selectDistinct(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
SelectSelectStep |
FactoryOperations.selectDistinct(Field<?>... fields)
Create a new DSL select statement.
|
<R extends Record> SimpleSelectWhereStep<R> |
FactoryOperations.selectFrom(Table<R> table)
Create a new DSL select statement
Example:
SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
|
SelectSelectStep |
FactoryOperations.selectOne()
Create a new DSL select statement for constant 1 literal
Example:
Factory create = new Factory();
create.selectOne()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
|
SelectQuery |
FactoryOperations.selectQuery()
|
<R extends Record> SimpleSelectQuery<R> |
FactoryOperations.selectQuery(TableLike<R> table)
|
SelectSelectStep |
FactoryOperations.selectZero()
Create a new DSL select statement for constant 0 literal
Example:
Factory create = new Factory();
create.selectZero()
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
|
LoaderCSVOptionsStep<R> |
LoaderCSVOptionsStep.separator(char separator)
Specify the separator character.
|
AggregateFunction<String> |
GroupConcatSeparatorStep.separator(String separator)
Specify the separator on the GROUP_CONCAT function
|
<T> UpdateSetMoreStep<R> |
UpdateSetStep.set(Field<T> field,
Field<T> value)
Set a value for a field in the UPDATE statement
|
<T> MergeNotMatchedSetMoreStep<R> |
MergeNotMatchedSetStep.set(Field<T> field,
Field<T> value)
Set values for INSERT in the MERGE statement's
WHEN NOT MATCHED clause
|
<T> MergeMatchedSetMoreStep<R> |
MergeMatchedSetStep.set(Field<T> field,
Field<T> value)
Set values for UPDATE in the MERGE statement's
WHEN MATCHED clause
|
<T> InsertSetMoreStep<R> |
InsertSetStep.set(Field<T> field,
Field<T> value)
Set a value for a field in the UPDATE statement
|
<T> InsertOnDuplicateSetMoreStep<R> |
InsertOnDuplicateSetStep.set(Field<T> field,
Field<T> value)
Set values for UPDATE in the INSERT statement's
ON DUPLICATE KEY UPDATE clause
|
<T> UpdateSetMoreStep<R> |
UpdateSetStep.set(Field<T> field,
T value)
Set a value for a field in the UPDATE statement
|
<T> MergeNotMatchedSetMoreStep<R> |
MergeNotMatchedSetStep.set(Field<T> field,
T value)
Set values for INSERT in the MERGE statement's
WHEN NOT MATCHED clause
|
<T> MergeMatchedSetMoreStep<R> |
MergeMatchedSetStep.set(Field<T> field,
T value)
Set values for UPDATE in the MERGE statement's
WHEN MATCHED clause
|
<T> InsertSetMoreStep<R> |
InsertSetStep.set(Field<T> field,
T value)
Set a value for a field in the UPDATE statement
|
<T> InsertOnDuplicateSetMoreStep<R> |
InsertOnDuplicateSetStep.set(Field<T> field,
T value)
Set values for UPDATE in the INSERT statement's
ON DUPLICATE KEY UPDATE clause
|
UpdateSetMoreStep<R> |
UpdateSetStep.set(Map<? extends Field<?>,?> map)
Set a value for a field in the UPDATE statement
Please assure that key/value pairs have matching <T>
types.
|
MergeNotMatchedSetMoreStep<R> |
MergeNotMatchedSetStep.set(Map<? extends Field<?>,?> map)
Set multiple values for INSERT in the MERGE
statement's WHEN NOT MATCHED clause.
|
MergeMatchedSetMoreStep<R> |
MergeMatchedSetStep.set(Map<? extends Field<?>,?> map)
Set multiple values for UPDATE in the MERGE
statement's WHEN MATCHED clause.
|
InsertSetMoreStep<R> |
InsertSetStep.set(Map<? extends Field<?>,?> map)
Set a value for a field in the UPDATE statement
Please assure that key/value pairs have matching <T>
types.
|
InsertOnDuplicateSetMoreStep<R> |
InsertOnDuplicateSetStep.set(Map<? extends Field<?>,?> map)
Set multiple values for UPDATE in the INSERT
statement's ON DUPLICATE KEY UPDATE clause
Please assure that key/value pairs have matching <T>
types.
|
void |
SelectQuery.setConnectByStartWith(Condition condition)
Add an Oracle-specific START WITH clause to the query's
CONNECT BY clause
|
void |
SelectQuery.setDistinct(boolean distinct)
Add "distinct" keyword to the select clause
|
void |
SimpleSelectQuery.setForShare(boolean forShare)
|
void |
SelectQuery.setForShare(boolean forShare)
|
void |
LockProvider.setForShare(boolean forShare)
Deprecated.
|
void |
SimpleSelectQuery.setForUpdate(boolean forUpdate)
Sets the "FOR UPDATE" flag onto the query
Native implementation This has been observed to be supported by
any of these dialects:
void |
SelectQuery.setForUpdate(boolean forUpdate)
Sets the "FOR UPDATE" flag onto the query
Native implementation This has been observed to be supported by
any of these dialects:
void |
LockProvider.setForUpdate(boolean forUpdate)
Deprecated.
Sets the "FOR UPDATE" flag onto the query
Native implementation This has been observed to be supported by
any of these dialects:
void |
SimpleSelectQuery.setForUpdateNoWait()
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
| | |
void |
SelectQuery.setForUpdateNoWait()
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
LockProvider.setForUpdateNoWait()
Deprecated.
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
SimpleSelectQuery.setForUpdateOf(Collection<? extends Field<?>> fields)
Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
SelectQuery.setForUpdateOf(Collection<? extends Field<?>> fields)
Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
LockProvider.setForUpdateOf(Collection<? extends Field<?>> fields)
Deprecated.
Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
SimpleSelectQuery.setForUpdateOf(Field<?>... fields)
Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
SelectQuery.setForUpdateOf(Field<?>... fields)
Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
LockProvider.setForUpdateOf(Field<?>... fields)
Deprecated.
Some RDBMS allow for specifying the fields that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
SimpleSelectQuery.setForUpdateOf(Table<?>... tables)
Some RDBMS allow for specifying the tables that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
SelectQuery.setForUpdateOf(Table<?>... tables)
Some RDBMS allow for specifying the tables that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
LockProvider.setForUpdateOf(Table<?>... tables)
Deprecated.
Some RDBMS allow for specifying the tables that should be locked by the
FOR UPDATE clause, instead of the full row.
|
void |
SimpleSelectQuery.setForUpdateSkipLocked()
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
SelectQuery.setForUpdateSkipLocked()
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
LockProvider.setForUpdateSkipLocked()
Deprecated.
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
SimpleSelectQuery.setForUpdateWait(int seconds)
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
SelectQuery.setForUpdateWait(int seconds)
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
LockProvider.setForUpdateWait(int seconds)
Deprecated.
Some RDBMS allow for specifying the locking mode for the applied
FOR UPDATE clause.
|
void |
SimpleSelectQuery.setOrderBySiblings(boolean orderBySiblings)
Indicate whether the SIBLINGS keyword should be used in an
ORDER BY clause to form an ORDER SIBLINGS BY
clause.
|
void |
SelectQuery.setOrderBySiblings(boolean orderBySiblings)
Indicate whether the SIBLINGS keyword should be used in an
ORDER BY clause to form an ORDER SIBLINGS BY
clause.
|
void |
OrderProvider.setOrderBySiblings(boolean orderBySiblings)
Deprecated.
Indicate whether the SIBLINGS keyword should be used in an
ORDER BY clause to form an ORDER SIBLINGS BY
clause.
|
void |
StoreQuery.setRecord(R record)
Add values to the store statement
|
void |
InsertQuery.setReturning()
Configure the INSERT statement to return all fields in
R .
|
void |
InsertQuery.setReturning(Collection<? extends Field<?>> fields)
Configure the INSERT statement to return a list of fields in
R .
|
void |
InsertQuery.setReturning(Field<?>... fields)
Configure the INSERT statement to return a list of fields in
R .
|
void |
InsertQuery.setReturning(Identity<R,? extends Number> identity)
Configure the INSERT statement to return the generated
identity value.
|
Field<Integer> |
Field.sign()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.sin()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.sinh()
This method is part of the pre-2.0 API.
|
SimpleSelectFinalStep<R> |
SimpleSelectForUpdateWaitStep.skipLocked()
Add a WAIT clause to the FOR UPDATE clause at
the end of the query.
|
SelectFinalStep |
SelectForUpdateWaitStep.skipLocked()
Add a WAIT clause to the FOR UPDATE clause at
the end of the query.
|
<Z> SortField<Z> |
Field.sort(Map<T,Z> sortMap)
Create a sort field of the form (in pseudo code)
CASE [this] WHEN [sortMap.key(0)] THEN sortMap.value(0)
WHEN [sortMap.key(1)] THEN sortMap.value(1)
...
|
SortField<T> |
Field.sort(SortOrder order)
Create an ascending/descending sort field from this field
|
SortField<Integer> |
Field.sortAsc(Collection<T> sortList)
Create a sort field of the form
CASE [this] WHEN [sortList.get(0)] THEN 0
WHEN [sortList.get(1)] THEN 1
...
|
SortField<Integer> |
Field.sortAsc(T... sortList)
Create a sort field of the form
CASE [this] WHEN [sortList[0]] THEN 0
WHEN [sortList[1]] THEN 1
...
|
SortField<Integer> |
Field.sortDesc(Collection<T> sortList)
Create a sort field of the form
CASE [this] WHEN [sortList.get(0)] THEN 0
WHEN [sortList.get(1)] THEN 1
...
|
SortField<Integer> |
Field.sortDesc(T... sortList)
Create a sort field of the form
CASE [this] WHEN [sortList[0]] THEN 0
WHEN [sortList[1]] THEN 1
...
|
Field<BigDecimal> |
Field.sqrt()
This method is part of the pre-2.0 API.
|
Condition |
Field.startsWith(Field<T> value)
Convenience method for Field.like(String, char) including proper
adding of wildcards and escaping
SQL: this like (escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance
val(1133).startsWith(11)
|
Condition |
Field.startsWith(T value)
Convenience method for Field.like(String, char) including proper
adding of wildcards and escaping
SQL: this like (escape(value, '\') || '%') escape '\'
Note: This also works with numbers, for instance
val(1133).startsWith(11)
|
SelectGroupByStep |
SelectStartWithStep.startWith(Condition condition)
Add an Oracle-specific START WITH clause to the query's
CONNECT BY clause
|
SelectGroupByStep |
SelectStartWithStep.startWith(String sql)
Add an Oracle-specific START WITH clause to the query's
CONNECT BY clause
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectGroupByStep |
SelectStartWithStep.startWith(String sql,
Object... bindings)
Add an Oracle-specific START WITH clause to the query's
CONNECT BY clause
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectGroupByStep |
SelectStartWithStep.startWith(String sql,
QueryPart... parts)
Add an Oracle-specific START WITH clause to the query's
CONNECT BY clause
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
Field<BigDecimal> |
Field.stddevPop()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<BigDecimal> |
Field.stddevPopOver()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.stddevSamp()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<BigDecimal> |
Field.stddevSampOver()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.sub(Field<?> value)
An arithmetic expression subtracting value from this.
|
Field<T> |
Field.sub(Number value)
An arithmetic expression subtracting value from this.
|
Field<String> |
Field.substring(Field<? extends Number> startingPosition)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.substring(Field<? extends Number> startingPosition,
Field<? extends Number> length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.substring(int startingPosition)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.substring(int startingPosition,
int length)
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.sum()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<BigDecimal> |
Field.sumOver()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.tan()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.tanh()
This method is part of the pre-2.0 API.
|
Field<String> |
Field.trim()
This method is part of the pre-2.0 API.
|
<R extends Record> Truncate<R> |
FactoryOperations.truncate(Table<R> table)
Create a new DSL truncate statement.
|
Select<R> |
Select.union(Select<R> select)
Combine with other selects
|
Select<R> |
Select.unionAll(Select<R> select)
Combine with other selects
|
<R extends Record> UpdateSetStep<R> |
FactoryOperations.update(Table<R> table)
Create a new DSL update statement.
|
<R extends Record> UpdateQuery<R> |
FactoryOperations.updateQuery(Table<R> table)
|
Field<String> |
Field.upper()
This method is part of the pre-2.0 API.
|
int |
FactoryOperations.use(Schema schema)
Use a schema as the default schema of the underlying connection.
|
int |
FactoryOperations.use(String schema)
Use a schema as the default schema of the underlying connection.
|
Table<Record> |
TableOnStep.using(Collection<? extends Field<?>> fields)
Join the table with the USING(column [, column...])
|
SelectJoinStep |
SelectOnStep.using(Collection<? extends Field<?>> fields)
Join the previous table with the USING(column [, column...])
|
Table<Record> |
TableOnStep.using(Field<?>... fields)
Join the table with the USING(column [, column...])
|
SelectJoinStep |
SelectOnStep.using(Field<?>... fields)
Join the previous table with the USING(column [, column...])
|
MergeOnStep<R> |
MergeUsingStep.using(TableLike<?> table)
Add the USING clause to the SQL standard MERGE
statement
|
MergeOnStep<R> |
MergeUsingStep.usingDual()
Add a dummy USING clause to the SQL standard
MERGE statement
This results in USING(SELECT 1 FROM DUAL) for most RDBMS, or
in USING(SELECT 1) AS [dummy_table(dummy_field)] in SQL
Server, where derived tables need to be aliased.
|
<V> CaseValueStep<V> |
Case.value(Field<V> value)
This construct can be used to create expressions of the type
CASE value WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
|
<V> CaseValueStep<V> |
Case.value(V value)
This construct can be used to create expressions of the type
CASE value WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
|
Merge<R> |
MergeValuesStep.values(Collection<?> values)
Specify a VALUES clause
|
MergeNotMatchedWhereStep<R> |
MergeNotMatchedValuesStep.values(Collection<?> values)
Set VALUES for INSERT in the MERGE
statement's WHEN NOT MATCHED THEN INSERT clause.
|
InsertValuesStep<R> |
InsertValuesStep.values(Collection<?> values)
Add values to the insert statement
|
InsertValuesStep<R> |
InsertSetStep.values(Collection<?> values)
Add values to the insert statement with implicit field names
|
Merge<R> |
MergeValuesStep.values(Field<?>... values)
Specify a VALUES clause
|
MergeNotMatchedWhereStep<R> |
MergeNotMatchedValuesStep.values(Field<?>... values)
Set VALUES for INSERT in the MERGE
statement's WHEN NOT MATCHED THEN INSERT clause.
|
InsertValuesStep<R> |
InsertValuesStep.values(Field<?>... values)
Add values to the insert statement
|
InsertValuesStep<R> |
InsertSetStep.values(Field<?>... values)
Add values to the insert statement with implicit field names
|
Merge<R> |
MergeValuesStep.values(Object... values)
Specify a VALUES clause
|
MergeNotMatchedWhereStep<R> |
MergeNotMatchedValuesStep.values(Object... values)
Set VALUES for INSERT in the MERGE
statement's WHEN NOT MATCHED THEN INSERT clause.
|
InsertValuesStep<R> |
InsertValuesStep.values(Object... values)
Add values to the insert statement
|
InsertValuesStep<R> |
InsertSetStep.values(Object... values)
Add values to the insert statement with implicit field names
|
Field<BigDecimal> |
Field.varPop()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<BigDecimal> |
Field.varPopOver()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.varSamp()
This method is part of the pre-2.0 API.
|
WindowPartitionByStep<BigDecimal> |
Field.varSampOver()
This method is part of the pre-2.0 API.
|
SimpleSelectFinalStep<R> |
SimpleSelectForUpdateWaitStep.wait(int seconds)
Add a WAIT clause to the FOR UPDATE clause at
the end of the query.
|
SelectFinalStep |
SelectForUpdateWaitStep.wait(int seconds)
Add a WAIT clause to the FOR UPDATE clause at
the end of the query.
|
CaseConditionStep<T> |
CaseConditionStep.when(Condition condition,
Field<T> result)
Compare a condition to the already constructed case statement, return
result if the condition holds true
|
<T> CaseConditionStep<T> |
Case.when(Condition condition,
Field<T> result)
This construct can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Instances of Case are created through the
|
CaseConditionStep<T> |
CaseConditionStep.when(Condition condition,
T result)
Compare a condition to the already constructed case statement, return
result if the condition holds true
|
<T> CaseConditionStep<T> |
Case.when(Condition condition,
T result)
This construct can be used to create expressions of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
Instances of Case are created through the
|
CaseWhenStep<V,T> |
CaseWhenStep.when(Field<V> compareValue,
Field<T> result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
<T> CaseWhenStep<V,T> |
CaseValueStep.when(Field<V> compareValue,
Field<T> result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
CaseWhenStep<V,T> |
CaseWhenStep.when(Field<V> compareValue,
T result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
<T> CaseWhenStep<V,T> |
CaseValueStep.when(Field<V> compareValue,
T result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
CaseWhenStep<V,T> |
CaseWhenStep.when(V compareValue,
Field<T> result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
<T> CaseWhenStep<V,T> |
CaseValueStep.when(V compareValue,
Field<T> result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
CaseWhenStep<V,T> |
CaseWhenStep.when(V compareValue,
T result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
<T> CaseWhenStep<V,T> |
CaseValueStep.when(V compareValue,
T result)
Compare a value to the already constructed case statement, return result
if values are equal.
|
MergeMatchedSetStep<R> |
MergeMatchedStep.whenMatchedThenUpdate()
Add the WHEN MATCHED THEN UPDATE clause to the
MERGE statement
|
MergeNotMatchedSetStep<R> |
MergeNotMatchedStep.whenNotMatchedThenInsert()
Add the WHEN NOT MATCHED THEN INSERT clause to the
MERGE statement.
|
MergeNotMatchedValuesStep<R> |
MergeNotMatchedStep.whenNotMatchedThenInsert(Collection<? extends Field<?>> fields)
Add the WHEN MATCHED THEN UPDATE clause to the
MERGE statement
|
MergeNotMatchedValuesStep<R> |
MergeNotMatchedStep.whenNotMatchedThenInsert(Field<?>... fields)
Add the WHEN NOT MATCHED THEN INSERT clause to the
MERGE statement
|
UpdateConditionStep<R> |
UpdateWhereStep.where(Collection<Condition> conditions)
Add conditions to the query
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.where(Collection<Condition> conditions)
Add a WHERE clause to the query
|
SelectConditionStep |
SelectWhereStep.where(Collection<Condition> conditions)
Add a WHERE clause to the query
|
DeleteConditionStep<R> |
DeleteWhereStep.where(Collection<Condition> conditions)
Add conditions to the query
|
UpdateConditionStep<R> |
UpdateWhereStep.where(Condition... conditions)
Add conditions to the query
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.where(Condition... conditions)
Add a WHERE clause to the query
|
SelectConditionStep |
SelectWhereStep.where(Condition... conditions)
Add a WHERE clause to the query
|
DeleteConditionStep<R> |
DeleteWhereStep.where(Condition... conditions)
Add conditions to the query
|
MergeFinalStep<R> |
MergeNotMatchedWhereStep.where(Condition condition)
Add an additional WHERE clause to the preceding
WHEN NOT MATCHED THEN INSERT clause.
|
MergeMatchedDeleteStep<R> |
MergeMatchedWhereStep.where(Condition condition)
Add an additional WHERE clause to the preceding
WHEN MATCHED THEN UPDATE clause.
|
UpdateConditionStep<R> |
UpdateWhereStep.where(String sql)
Add conditions to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.where(String sql)
Add a WHERE clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConditionStep |
SelectWhereStep.where(String sql)
Add a WHERE clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
DeleteConditionStep<R> |
DeleteWhereStep.where(String sql)
Add conditions to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
UpdateConditionStep<R> |
UpdateWhereStep.where(String sql,
Object... bindings)
Add conditions to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.where(String sql,
Object... bindings)
Add a WHERE clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConditionStep |
SelectWhereStep.where(String sql,
Object... bindings)
Add a WHERE clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
DeleteConditionStep<R> |
DeleteWhereStep.where(String sql,
Object... bindings)
Add conditions to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
UpdateConditionStep<R> |
UpdateWhereStep.where(String sql,
QueryPart... parts)
Add conditions to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.where(String sql,
QueryPart... parts)
Add a WHERE clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
SelectConditionStep |
SelectWhereStep.where(String sql,
QueryPart... parts)
Add a WHERE clause to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
DeleteConditionStep<R> |
DeleteWhereStep.where(String sql,
QueryPart... parts)
Add conditions to the query
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
UpdateConditionStep<R> |
UpdateWhereStep.whereExists(Select<?> select)
Add an EXISTS clause to the query
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.whereExists(Select<?> select)
Add a WHERE EXISTS clause to the query
|
SelectConditionStep |
SelectWhereStep.whereExists(Select<?> select)
Add a WHERE EXISTS clause to the query
|
DeleteConditionStep<R> |
DeleteWhereStep.whereExists(Select<?> select)
Add an EXISTS clause to the query
|
UpdateConditionStep<R> |
UpdateWhereStep.whereNotExists(Select<?> select)
Add a NOT EXISTS clause to the query
|
SimpleSelectConditionStep<R> |
SimpleSelectWhereStep.whereNotExists(Select<?> select)
Add a WHERE NOT EXISTS clause to the query
|
SelectConditionStep |
SelectWhereStep.whereNotExists(Select<?> select)
Add a WHERE NOT EXISTS clause to the query
|
DeleteConditionStep<R> |
DeleteWhereStep.whereNotExists(Select<?> select)
Add a NOT EXISTS clause to the query
|
AggregateFunction<T> |
OrderedAggregateFunction.withinGroupOrderBy(Collection<SortField<?>> fields)
Add an WITHIN GROUP (ORDER BY ..)
|
AggregateFunction<T> |
OrderedAggregateFunction.withinGroupOrderBy(Field<?>... fields)
Add an WITHIN GROUP (ORDER BY ..)
|
AggregateFunction<T> |
OrderedAggregateFunction.withinGroupOrderBy(SortField<?>... fields)
Add an WITHIN GROUP (ORDER BY ..)
|
Methods in org.jooq.impl with annotations of type Support
Modifier and Type |
Method and Description |
static <T extends Number> Field<T> |
Factory.abs(Field<T> field)
Get the absolute value of a numeric field: abs(field)
This renders the same on all dialects:
abs([field])
|
static <T extends Number> Field<T> |
Factory.abs(T value)
Get the absolute value of a numeric field: abs(field)
|
static Field<BigDecimal> |
Factory.acos(Field<? extends Number> field)
Get the arc cosine(field) function
This renders the acos function where available:
acos([field])
|
static Field<BigDecimal> |
Factory.acos(Number value)
Get the arc cosine(field) function
|
static Field<Integer> |
Factory.ascii(Field<String> field)
Get the ascii(field) function
This renders the ascii function:
ascii([field])
|
static Field<Integer> |
Factory.ascii(String field)
Get the ascii(field) function
|
static Field<BigDecimal> |
Factory.asin(Field<? extends Number> field)
Get the arc sine(field) function
This renders the asin function where available:
asin([field])
|
static Field<BigDecimal> |
Factory.asin(Number value)
Get the arc sine(field) function
|
static Field<BigDecimal> |
Factory.atan(Field<? extends Number> field)
Get the arc tangent(field) function
This renders the atan function where available:
atan([field])
|
static Field<BigDecimal> |
Factory.atan(Number value)
Get the arc tangent(field) function
|
static Field<BigDecimal> |
Factory.atan2(Field<? extends Number> x,
Field<? extends Number> y)
Get the atan2(field, y) function
This renders the atan2 or atn2 function where available:
atan2([x], [y]) or
atn2([x], [y])
|
static Field<BigDecimal> |
Factory.atan2(Field<? extends Number> x,
Number y)
Get the atan2(field, y) function
|
static Field<BigDecimal> |
Factory.atan2(Number x,
Field<? extends Number> y)
Get the atan2(field, y) function
|
static Field<BigDecimal> |
Factory.atan2(Number x,
Number y)
Get the atan2(field, y) function
|
static AggregateFunction<BigDecimal> |
Factory.avg(Field<? extends Number> field)
Get the average over a numeric field: avg(field)
|
static AggregateFunction<BigDecimal> |
Factory.avgDistinct(Field<? extends Number> field)
Get the average over a numeric field: avg(distinct field)
|
static <T extends Number> Field<T> |
Factory.bitAnd(Field<T> field1,
Field<T> field2)
The bitwise and operator.
|
static <T extends Number> Field<T> |
Factory.bitAnd(Field<T> value1,
T value2)
The bitwise and operator.
|
static <T extends Number> Field<T> |
Factory.bitAnd(T value1,
Field<T> value2)
The bitwise and operator.
|
static <T extends Number> Field<T> |
Factory.bitAnd(T value1,
T value2)
The bitwise and operator.
|
static Field<Integer> |
Factory.bitCount(Field<? extends Number> field)
The MySQL BIT_COUNT(field) function, counting the number of
bits that are set in this number.
|
static Field<Integer> |
Factory.bitCount(Number value)
The MySQL BIT_COUNT(field) function, counting the number of
bits that are set in this number.
|
static Field<Integer> |
Factory.bitLength(Field<String> field)
Get the bit_length(field) function
This translates into any dialect
|
static Field<Integer> |
Factory.bitLength(String value)
Get the bit_length(field) function
This translates into any dialect
|
static <T extends Number> Field<T> |
Factory.bitNand(Field<T> field1,
Field<T> field2)
The bitwise not and operator.
|
static <T extends Number> Field<T> |
Factory.bitNand(Field<T> value1,
T value2)
The bitwise not and operator.
|
static <T extends Number> Field<T> |
Factory.bitNand(T value1,
Field<T> value2)
The bitwise not and operator.
|
static <T extends Number> Field<T> |
Factory.bitNand(T value1,
T value2)
The bitwise not and operator.
|
static <T extends Number> Field<T> |
Factory.bitNor(Field<T> field1,
Field<T> field2)
The bitwise not or operator.
|
static <T extends Number> Field<T> |
Factory.bitNor(Field<T> value1,
T value2)
The bitwise not or operator.
|
static <T extends Number> Field<T> |
Factory.bitNor(T value1,
Field<T> value2)
The bitwise not or operator.
|
static <T extends Number> Field<T> |
Factory.bitNor(T value1,
T value2)
The bitwise not or operator.
|
static <T extends Number> Field<T> |
Factory.bitNot(Field<T> field)
The bitwise not operator.
|
static <T extends Number> Field<T> |
Factory.bitNot(T value)
The bitwise not operator.
|
static <T extends Number> Field<T> |
Factory.bitOr(Field<T> field1,
Field<T> field2)
The bitwise or operator.
|
static <T extends Number> Field<T> |
Factory.bitOr(Field<T> value1,
T value2)
The bitwise or operator.
|
static <T extends Number> Field<T> |
Factory.bitOr(T value1,
Field<T> value2)
The bitwise or operator.
|
static <T extends Number> Field<T> |
Factory.bitOr(T value1,
T value2)
The bitwise or operator.
|
static <T extends Number> Field<T> |
Factory.bitXNor(Field<T> field1,
Field<T> field2)
The bitwise not xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXNor(Field<T> value1,
T value2)
The bitwise not xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXNor(T value1,
Field<T> value2)
The bitwise not xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXNor(T value1,
T value2)
The bitwise not xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXor(Field<T> field1,
Field<T> field2)
The bitwise xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXor(Field<T> value1,
T value2)
The bitwise xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXor(T value1,
Field<T> value2)
The bitwise xor operator.
|
static <T extends Number> Field<T> |
Factory.bitXor(T value1,
T value2)
The bitwise xor operator.
|
static <T> Field<T> |
Factory.cast(Object value,
Class<? extends T> type)
Cast a value to another type
|
static <T> Field<T> |
Factory.cast(Object value,
DataType<T> type)
Cast a value to another type
|
static <T> Field<T> |
Factory.cast(Object value,
Field<T> as)
Cast a value to the type of another field.
|
static <T> Field<T> |
Factory.castNull(Class<? extends T> type)
Cast null to a type
|
static <T> Field<T> |
Factory.castNull(DataType<T> type)
Cast null to a type
|
static <T> Field<T> |
Factory.castNull(Field<T> as)
Cast null to the type of another field.
|
static <T extends Number> Field<T> |
Factory.ceil(Field<T> field)
Get the smallest integer value not less than [field]
This renders the ceil or ceiling function where available:
ceil([field]) or
ceiling([field])
... or simulates it elsewhere using round:
round([field] + 0.499999999999999)
|
static <T extends Number> Field<T> |
Factory.ceil(T value)
Get the smallest integer value not less than [this]
|
static Field<Integer> |
Factory.charLength(Field<String> field)
Get the char_length(field) function
This translates into any dialect
|
static Field<Integer> |
Factory.charLength(String value)
Get the char_length(field) function
This translates into any dialect
|
static <T> Field<T> |
Factory.coalesce(Field<T> field,
Field<?>... fields)
Gets the Oracle-style COALESCE(field1, field2, ... , field n)
function
Returns the dialect's equivalent to COALESCE:
Oracle COALESCE
|
static <T> Field<T> |
Factory.coalesce(T value,
T... values)
Gets the Oracle-style COALESCE(value1, value2, ... , value n)
function
|
static Field<String> |
Factory.concat(Field<?>... fields)
Get the concat(field[, field, ...]) function
This creates fields[0] || fields[1] || ...
|
static Field<String> |
Factory.concat(String... values)
Get the concat(value[, value, ...]) function
|
static Condition |
Factory.condition(String sql)
Create a new condition holding plain SQL.
|
static Condition |
Factory.condition(String sql,
Object... bindings)
Create a new condition holding plain SQL.
|
static Condition |
Factory.condition(String sql,
QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.
|
static Field<Boolean> |
Factory.connectByIsCycle()
Retrieve the Oracle-specific CONNECT_BY_ISCYCLE pseudo-field
(to be used along with CONNECT BY clauses)
|
static Field<Boolean> |
Factory.connectByIsLeaf()
Retrieve the Oracle-specific CONNECT_BY_ISLEAF pseudo-field
(to be used along with CONNECT BY clauses)
|
static <T> Field<T> |
Factory.connectByRoot(Field<T> field)
Retrieve the Oracle-specific CONNECT_BY_ROOT pseudo-column
(to be used along with CONNECT BY clauses)
|
static Field<BigDecimal> |
Factory.cos(Field<? extends Number> field)
Get the cosine(field) function
This renders the cos function where available:
cos([field])
|
static Field<BigDecimal> |
Factory.cos(Number value)
Get the cosine(field) function
|
static Field<BigDecimal> |
Factory.cosh(Field<? extends Number> field)
Get the hyperbolic cosine function: cosh(field)
This renders the cosh function where available:
cosh([field]) ... or simulates it elsewhere using
exp: (exp([field] * 2) + 1) / (exp([field] * 2))
|
static Field<BigDecimal> |
Factory.cosh(Number value)
Get the hyperbolic cosine function: cosh(field)
|
static Field<BigDecimal> |
Factory.cot(Field<? extends Number> field)
Get the cotangent(field) function
This renders the cot function where available:
cot([field]) ... or simulates it elsewhere using
sin and cos: cos([field]) / sin([field])
|
static Field<BigDecimal> |
Factory.cot(Number value)
Get the cotangent(field) function
|
static Field<BigDecimal> |
Factory.coth(Field<? extends Number> field)
Get the hyperbolic cotangent function: coth(field)
This is not supported by any RDBMS, but simulated using exp exp:
(exp([field] * 2) + 1) / (exp([field] * 2) - 1)
|
static Field<BigDecimal> |
Factory.coth(Number value)
Get the hyperbolic cotangent function: coth(field)
|
static AggregateFunction<Integer> |
Factory.count()
Get the count(*) function
|
static AggregateFunction<Integer> |
Factory.count(Field<?> field)
Get the count(field) function
|
static AggregateFunction<Integer> |
Factory.countDistinct(Field<?>... fields)
Get the count(distinct field1, field2) function
Some dialects support several expressions in the COUNT(DISTINCT expr1, expr2) aggregate function.
|
static AggregateFunction<Integer> |
Factory.countDistinct(Field<?> field)
Get the count(distinct field) function
|
static Field<?> |
Factory.cube(Field<?>... fields)
Create a CUBE(field1, field2, .., fieldn) grouping field
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of
CUBE , ROLLUP , and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
|
static WindowOverStep<BigDecimal> |
Factory.cumeDist()
The cume_dist() over ([analytic clause]) function.
|
static Field<Date> |
Factory.currentDate()
Get the current_date() function
This translates into any dialect
|
static Field<Time> |
Factory.currentTime()
Get the current_time() function
This translates into any dialect
|
static Field<Timestamp> |
Factory.currentTimestamp()
Get the current_timestamp() function
This translates into any dialect
|
static Field<String> |
Factory.currentUser()
Get the current_user() function
This translates into any dialect
|
static Field<Date> |
Factory.dateAdd(Date date,
Number interval)
Add an interval to a date
This translates into any dialect
|
static Field<Date> |
Factory.dateAdd(Field<Date> date,
Field<? extends Number> interval)
Add an interval to a date
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Date date1,
Date date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Date date1,
Field<Date> date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Field<Date> date1,
Date date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Field<Date> date1,
Field<Date> date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.day(Date value)
|
static Field<Integer> |
Factory.day(Field<? extends Date> field)
|
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)
|
static String |
Factory.escape(String value,
char escape)
|
static Condition |
Factory.exists(Select<?> query)
Create an exists condition.
|
static Field<BigDecimal> |
Factory.exp(Field<? extends Number> field)
Get the exp(field) function, taking this field as the power of e
This renders the same on all dialects:
exp([field])
|
static Field<BigDecimal> |
Factory.exp(Number value)
Get the exp(field) function, taking this field as the power of e
|
static Field<Integer> |
Factory.extract(Date value,
DatePart datePart)
Get the extract(field, datePart) function
This translates into any dialect
|
static Field<Integer> |
Factory.extract(Field<? extends Date> field,
DatePart datePart)
Get the extract(field, datePart) function
This translates into any dialect
|
static Condition |
Factory.falseCondition()
Return a Condition that will always evaluate to false
|
static Field<Object> |
Factory.field(String sql)
A PlainSQLField is a field that can contain user-defined plain SQL,
because sometimes it is easier to express things directly in SQL, for
instance complex proprietary functions.
|
static <T> Field<T> |
Factory.field(String sql,
Class<T> type)
A PlainSQLField is a field that can contain user-defined plain SQL,
because sometimes it is easier to express things directly in SQL, for
instance complex proprietary functions.
|
static <T> Field<T> |
Factory.field(String sql,
Class<T> type,
Object... bindings)
A PlainSQLField is a field that can contain user-defined plain SQL,
because sometimes it is easier to express things directly in SQL, for
instance complex proprietary functions.
|
static <T> Field<T> |
Factory.field(String sql,
DataType<T> type)
A PlainSQLField is a field that can contain user-defined plain SQL,
because sometimes it is easier to express things directly in SQL, for
instance complex proprietary functions.
|
static <T> Field<T> |
Factory.field(String sql,
DataType<T> type,
Object... bindings)
A PlainSQLField is a field that can contain user-defined plain SQL,
because sometimes it is easier to express things directly in SQL, for
instance complex proprietary functions.
|
static Field<Object> |
Factory.field(String sql,
Object... bindings)
A PlainSQLField is a field that can contain user-defined plain SQL,
because sometimes it is easier to express things directly in SQL, for
instance complex proprietary functions.
|
static <T> Field<T> |
Factory.fieldByName(Class<T> type,
String... qualifiedName)
Create a qualified field, given its (qualified) field name.
|
static <T> Field<T> |
Factory.fieldByName(DataType<T> type,
String... qualifiedName)
Create a qualified field, given its (qualified) field name.
|
static Field<Object> |
Factory.fieldByName(String... qualifiedName)
Create a qualified field, given its (qualified) field name.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.firstValue(Field<T> field)
The first_value(field) over ([analytic clause]) function.
|
static <T extends Number> Field<T> |
Factory.floor(Field<T> field)
Get the largest integer value not greater than [this]
This renders the floor function where available:
floor([this])
... or simulates it elsewhere using round:
round([this] - 0.499999999999999)
|
static <T extends Number> Field<T> |
Factory.floor(T value)
Get the largest integer value not greater than [this]
|
static <T> Field<T> |
Factory.function(String name,
Class<T> type,
Field<?>... arguments)
function() can be used to access native functions that are
not yet or insufficiently supported by jOOQ
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
static <T> Field<T> |
Factory.function(String name,
DataType<T> type,
Field<?>... arguments)
function() can be used to access native functions that are
not yet or insufficiently supported by jOOQ
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity.
|
static <T> DataType<T> |
Factory.getDataType(Class<? extends T> type)
Get the default data type for the Factory 's underlying
SQLDialect and a given Java type.
|
static <T> Field<T> |
Factory.greatest(Field<T> field,
Field<?>... others)
Find the greatest among all values
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere.
|
static <T> Field<T> |
Factory.greatest(T value,
T... values)
Find the greatest among all values
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere.
|
static GroupConcatOrderByStep |
Factory.groupConcat(Field<?> field)
Get the aggregated concatenation for a field.
|
static GroupConcatOrderByStep |
Factory.groupConcatDistinct(Field<?> field)
Get the aggregated concatenation for a field.
|
static Field<Integer> |
Factory.grouping(Field<?> field)
Create a GROUPING(field) aggregation field to be used along with
CUBE , ROLLUP , and GROUPING SETS
groupings
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
|
static Field<Integer> |
Factory.groupingId(Field<?>... fields)
Create a GROUPING_ID(field1, field2, .., fieldn) aggregation field to be
used along with CUBE , ROLLUP , and
GROUPING SETS groupings
This has been observed to work with the following databases:
Oracle
SQL Server
|
static Field<?> |
Factory.groupingSets(Collection<Field<?>>... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna,
fieldnb)) grouping field
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of
CUBE , ROLLUP , and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
|
static Field<?> |
Factory.groupingSets(Field<?>... fields)
Create a GROUPING SETS(field1, field2, .., fieldn) grouping field where
each grouping set only consists of a single field.
|
static Field<?> |
Factory.groupingSets(Field<?>[]... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna,
fieldnb)) grouping field
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of
CUBE , ROLLUP , and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
|
static Field<Integer> |
Factory.hour(Date value)
|
static Field<Integer> |
Factory.hour(Field<? extends Date> field)
|
static Param<String> |
Factory.inline(char character)
Create a bind value, that is always inlined.
|
static Param<String> |
Factory.inline(Character character)
Create a bind value, that is always inlined.
|
static Param<String> |
Factory.inline(CharSequence character)
Create a bind value, that is always inlined.
|
static <T> Param<T> |
Factory.inline(Object value,
Class<? extends T> type)
Create a bind value, that is always inlined.
|
static <T> Param<T> |
Factory.inline(Object value,
DataType<T> type)
Create a bind value, that is always inlined.
|
static <T> Param<T> |
Factory.inline(Object value,
Field<T> field)
Create a bind value, that is always inlined.
|
static <T> Param<T> |
Factory.inline(T value)
Create a bind value, that is always inlined.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lag(Field<T> field)
The lag(field) over ([analytic clause]) function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lag(Field<T> field,
int offset)
The lag(field, offset) over ([analytic clause]) function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lag(Field<T> field,
int offset,
Field<T> defaultValue)
The
lag(field, offset, defaultValue) over ([analytic clause])
function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lag(Field<T> field,
int offset,
T defaultValue)
The
lag(field, offset, defaultValue) over ([analytic clause])
function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lastValue(Field<T> field)
The last_value(field) over ([analytic clause]) function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lead(Field<T> field)
The lead(field) over ([analytic clause]) function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lead(Field<T> field,
int offset)
The lead(field, offset) over ([analytic clause]) function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lead(Field<T> field,
int offset,
Field<T> defaultValue)
The
lead(field, offset, defaultValue) over ([analytic clause])
function.
|
static <T> WindowIgnoreNullsStep<T> |
Factory.lead(Field<T> field,
int offset,
T defaultValue)
The
lead(field, offset, defaultValue) over ([analytic clause])
function.
|
static <T> Field<T> |
Factory.least(Field<T> field,
Field<?>... others)
Find the least among all values
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere.
|
static <T> Field<T> |
Factory.least(T value,
T... values)
Find the least among all values
This function has no equivalent in Adaptive Server, Derby, SQL Server and
Sybase SQL Anywhere.
|
static Field<Integer> |
Factory.length(Field<String> field)
Get the length of a VARCHAR type.
|
static Field<Integer> |
Factory.length(String value)
Get the length of a VARCHAR type.
|
static Field<Integer> |
Factory.level()
Retrieve the Oracle-specific LEVEL pseudo-field (to be used
along with CONNECT BY clauses)
|
static OrderedAggregateFunction<String> |
Factory.listAgg(Field<?> field)
Get the aggregated concatenation for a field.
|
static OrderedAggregateFunction<String> |
Factory.listAgg(Field<?> field,
String separator)
Get the aggregated concatenation for a field.
|
static <T> Field<T> |
Factory.literal(Object literal,
Class<T> type)
|
static <T> Field<T> |
Factory.literal(Object literal,
DataType<T> type)
|
static <T> Field<T> |
Factory.literal(T 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])
In SQLDialect.SQLITE , this is simulated as such:
replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '''', ''), '0', [character]) || [field]
|
static Field<String> |
Factory.lpad(Field<String> field,
int length)
Get the lpad(field, length) function
|
static Field<String> |
Factory.lpad(Field<String> field,
int length,
char character)
Get the lpad(field, length, character) function
|
static Field<String> |
Factory.lpad(Field<String> field,
int length,
String character)
Get the lpad(field, length, character) function
|
static Field<String> |
Factory.ltrim(Field<String> field)
Get the ltrim(field) function
This renders the ltrim function in all dialects:
ltrim([field])
|
static Field<String> |
Factory.ltrim(String value)
Get the ltrim(field) function
|
static <T> AggregateFunction<T> |
Factory.max(Field<T> field)
Get the max value over a field: max(field)
|
static <T> AggregateFunction<T> |
Factory.maxDistinct(Field<T> field)
Get the max value over a field: max(distinct field)
|
static AggregateFunction<BigDecimal> |
Factory.median(Field<? extends Number> field)
Get the median over a numeric field: median(field)
|
static <T> AggregateFunction<T> |
Factory.min(Field<T> field)
Get the min value over a field: min(field)
|
static <T> AggregateFunction<T> |
Factory.minDistinct(Field<T> field)
Get the min value over a field: min(distinct field)
|
static Field<Integer> |
Factory.minute(Date value)
|
static Field<Integer> |
Factory.minute(Field<? extends Date> field)
|
static Field<Integer> |
Factory.month(Date value)
|
static Field<Integer> |
Factory.month(Field<? extends Date> field)
|
static Condition |
Factory.not(Condition condition)
|
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)
|
static <T> Param<T> |
Factory.param(String name,
Class<? extends T> type)
Create a named parameter with a defined type and no initial value.
|
static <T> Param<T> |
Factory.param(String name,
DataType<T> type)
Create a named parameter with a defined type and no initial value.
|
static <T> Param<T> |
Factory.param(String name,
T value)
Create a named parameter with an initial value.
|
static WindowOverStep<BigDecimal> |
Factory.percentRank()
The precent_rank() over ([analytic clause]) function.
|
static Field<BigDecimal> |
Factory.pi()
The PI literal.
|
static Field<Integer> |
Factory.position(Field<String> in,
Field<String> search)
Get the position(in, search) function
This renders the position or any equivalent function:
position([search] in [in]) or
locate([in], [search]) or
locate([search], [in]) or
instr([in], [search]) or
charindex([search], [in])
|
static Field<Integer> |
Factory.position(Field<String> in,
String search)
Get the position(in, search) function
|
static Field<Integer> |
Factory.position(String in,
Field<String> search)
Get the position(in, search) function
|
static Field<Integer> |
Factory.position(String in,
String search)
Get the position(in, search) function
|
static Field<BigDecimal> |
Factory.power(Field<? extends Number> field,
Field<? extends Number> exponent)
Get the power(field, exponent) function
This renders the power function where available:
power([field], [exponent]) ... or simulates it
elsewhere using ln and exp:
exp(ln([field]) * [exponent])
|
static Field<BigDecimal> |
Factory.power(Field<? extends Number> field,
Number exponent)
Get the power(field, exponent) function
|
static Field<BigDecimal> |
Factory.power(Number value,
Field<? extends Number> exponent)
Get the power(field, exponent) function
|
static Field<BigDecimal> |
Factory.power(Number value,
Number exponent)
Get the power(field, exponent) function
|
static <T> Field<T> |
Factory.prior(Field<T> field)
Add the Oracle-specific PRIOR unary operator before a field
(to be used along with CONNECT BY clauses)
|
static Field<BigDecimal> |
Factory.rad(Field<? extends Number> field)
Calculate radians from degrees from this field
This renders the degrees function where available:
degrees([field]) ... or simulates it elsewhere:
[field] * PI / 180
|
static Field<BigDecimal> |
Factory.rad(Number value)
Calculate radians from degrees from this field
|
static Field<BigDecimal> |
Factory.rand()
Get the rand() function
|
static WindowOverStep<Integer> |
Factory.rank()
The rank_over() over ([analytic clause]) function.
|
static AggregateFunction<BigDecimal> |
Factory.regrAvgX(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_AVGX linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrAvgY(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_AVGY linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrCount(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_COUNT linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrIntercept(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_INTERCEPT linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrR2(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_R2 linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrSlope(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_SLOPE linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrSXX(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_SXX linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrSXY(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_SXY linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static AggregateFunction<BigDecimal> |
Factory.regrSYY(Field<? extends Number> y,
Field<? extends Number> x)
Get the REGR_SYY linear regression function
The linear regression functions fit an ordinary-least-squares regression
line to a set of number pairs.
|
static Field<String> |
Factory.repeat(Field<String> field,
Field<? extends Number> count)
Get the repeat(field, count) function
This renders the repeat or replicate function where available:
repeat([field], [count]) or
replicate([field], [count]) ... or simulates it elsewhere
using rpad and length, which may be simulated as well, depending on the
RDBMS:
rpad([field], length([field]) * [count], [field])
In SQLDialect.SQLITE , this is simulated as such:
replace(substr(quote(zeroblob(([count] + 1) / 2)), 3, [count]), '0', [field])
|
static Field<String> |
Factory.repeat(Field<String> field,
int count)
Get the repeat(count) function
|
static Field<String> |
Factory.repeat(String field,
Field<? extends Number> count)
Get the repeat(field, count) function
|
static Field<String> |
Factory.repeat(String field,
int count)
Get the repeat(field, count) function
|
static Field<String> |
Factory.replace(Field<String> field,
Field<String> search)
Get the replace(field, search) function
This renders the replace or str_replace function where available:
replace([field], [search]) or
str_replace([field], [search]) ... or simulates it elsewhere
using the three-argument replace function:
replace([field], [search], '')
|
static Field<String> |
Factory.replace(Field<String> field,
Field<String> search,
Field<String> replace)
Get the replace(field, search, replace) function
This renders the replace or str_replace function:
replace([field], [search]) or
str_replace([field], [search])
|
static Field<String> |
Factory.replace(Field<String> field,
String search)
Get the replace(field, search) function
|
static Field<String> |
Factory.replace(Field<String> field,
String search,
String replace)
Get the replace(field, search, replace) function
|
static Field<?> |
Factory.rollup(Field<?>... fields)
Create a ROLLUP(field1, field2, .., fieldn) grouping field
This has been observed to work with the following databases:
CUBRID (simulated using the GROUP BY ..
|
static <T extends Number> Field<T> |
Factory.round(Field<T> field)
Get rounded value of a numeric field: round(field)
This renders the round function where available:
round([field]) or
round([field], 0)
... or simulates it elsewhere using floor and ceil
|
static <T extends Number> Field<T> |
Factory.round(Field<T> field,
int decimals)
Get rounded value of a numeric field: round(field, decimals)
This renders the round function where available:
round([field], [decimals])
... or simulates it elsewhere using floor and ceil
|
static <T extends Number> Field<T> |
Factory.round(T value)
Get rounded value of a numeric field: round(field)
|
static <T extends Number> Field<T> |
Factory.round(T value,
int decimals)
Get rounded value of a numeric field: round(field, decimals)
|
static RowN |
Factory.row(Field<?>... values)
Create a row value expression of degree N > 8
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1> Row1<T1> |
Factory.row(Field<T1> t1)
Create a row value expression of degree 1
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2> Row2<T1,T2> |
Factory.row(Field<T1> t1,
Field<T2> t2)
Create a row value expression of degree 2
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3> Row3<T1,T2,T3> |
Factory.row(Field<T1> t1,
Field<T2> t2,
Field<T3> t3)
Create a row value expression of degree 3
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4> Row4<T1,T2,T3,T4> |
Factory.row(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4)
Create a row value expression of degree 4
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5> Row5<T1,T2,T3,T4,T5> |
Factory.row(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5)
Create a row value expression of degree 5
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5,T6> Row6<T1,T2,T3,T4,T5,T6> |
Factory.row(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6)
Create a row value expression of degree 6
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5,T6,T7> Row7<T1,T2,T3,T4,T5,T6,T7> |
Factory.row(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7)
Create a row value expression of degree 7
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5,T6,T7,T8> Row8<T1,T2,T3,T4,T5,T6,T7,T8> |
Factory.row(Field<T1> t1,
Field<T2> t2,
Field<T3> t3,
Field<T4> t4,
Field<T5> t5,
Field<T6> t6,
Field<T7> t7,
Field<T8> t8)
Create a row value expression of degree 8
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static RowN |
Factory.row(Object... values)
Create a row value expression of degree N > 8
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1> Row1<T1> |
Factory.row(T1 t1)
Create a row value expression of degree 1
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2> Row2<T1,T2> |
Factory.row(T1 t1,
T2 t2)
Create a row value expression of degree 2
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3> Row3<T1,T2,T3> |
Factory.row(T1 t1,
T2 t2,
T3 t3)
Create a row value expression of degree 3
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4> Row4<T1,T2,T3,T4> |
Factory.row(T1 t1,
T2 t2,
T3 t3,
T4 t4)
Create a row value expression of degree 4
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5> Row5<T1,T2,T3,T4,T5> |
Factory.row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5)
Create a row value expression of degree 5
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5,T6> Row6<T1,T2,T3,T4,T5,T6> |
Factory.row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6)
Create a row value expression of degree 6
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5,T6,T7> Row7<T1,T2,T3,T4,T5,T6,T7> |
Factory.row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7)
Create a row value expression of degree 7
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static <T1,T2,T3,T4,T5,T6,T7,T8> Row8<T1,T2,T3,T4,T5,T6,T7,T8> |
Factory.row(T1 t1,
T2 t2,
T3 t3,
T4 t4,
T5 t5,
T6 t6,
T7 t7,
T8 t8)
Create a row value expression of degree 8
Note: Not all databases support row value expressions, but many row value
expression operations can be simulated on all databases.
|
static WindowOverStep<Integer> |
Factory.rowNumber()
The row_number() over ([analytic clause]) function.
|
static Field<String> |
Factory.rpad(Field<String> field,
Field<? extends Number> length)
Get the rpad(field, length) function
This renders the rpad function where available:
rpad([field], [length]) ... or simulates it
elsewhere using concat, repeat, and length, which may be simulated as
well, depending on the RDBMS:
concat([field], repeat(' ', [length] - length([field])))
|
static Field<String> |
Factory.rpad(Field<String> field,
Field<? extends Number> length,
Field<String> character)
Get the rpad(field, length, character) function
This renders the rpad function where available:
rpad([field], [length]) ... or simulates it
elsewhere using concat, repeat, and length, which may be simulated as
well, depending on the RDBMS:
concat([field], repeat([character], [length] - length([field])))
In SQLDialect.SQLITE , this is simulated as such:
[field] || replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '''', ''), '0', [character])
|
static Field<String> |
Factory.rpad(Field<String> field,
int length)
Get the rpad(field, length) function
|
static Field<String> |
Factory.rpad(Field<String> field,
int length,
char character)
Get the rpad(field, length, character) function
|
static Field<String> |
Factory.rpad(Field<String> field,
int length,
String character)
Get the rpad(field, length, character) function
|
static Field<String> |
Factory.rtrim(Field<String> field)
Get the rtrim(field) function
This renders the rtrim function in all dialects:
rtrim([field])
|
static Field<String> |
Factory.rtrim(String value)
Get the rtrim(field) function
|
static Schema |
Factory.schemaByName(String name)
Create a qualified schema, given its schema name
This constructs a schema reference given the schema's qualified name.
|
static Field<Integer> |
Factory.second(Date value)
|
static Field<Integer> |
Factory.second(Field<? extends Date> field)
|
static <T extends Number> Field<T> |
Factory.shl(Field<T> field1,
Field<T> field2)
The bitwise left shift operator.
|
static <T extends Number> Field<T> |
Factory.shl(Field<T> value1,
T value2)
The bitwise left shift operator.
|
static <T extends Number> Field<T> |
Factory.shl(T value1,
Field<T> value2)
The bitwise left shift operator.
|
static <T extends Number> Field<T> |
Factory.shl(T value1,
T value2)
The bitwise left shift operator.
|
static <T extends Number> Field<T> |
Factory.shr(Field<T> field1,
Field<T> field2)
The bitwise right shift operator.
|
static <T extends Number> Field<T> |
Factory.shr(Field<T> value1,
T value2)
The bitwise right shift operator.
|
static <T extends Number> Field<T> |
Factory.shr(T value1,
Field<T> value2)
The bitwise right shift operator.
|
static <T extends Number> Field<T> |
Factory.shr(T value1,
T value2)
The bitwise right shift operator.
|
static Field<Integer> |
Factory.sign(Field<? extends Number> field)
Get the sign of a numeric field: sign(field)
This renders the sign function where available:
sign([field])
... or simulates it elsewhere (without bind variables on values -1, 0, 1):
CASE WHEN [this] > 0 THEN 1
WHEN [this] < 0 THEN -1
ELSE 0
END
|
static Field<Integer> |
Factory.sign(Number value)
Get the sign of a numeric field: sign(field)
|
static Field<BigDecimal> |
Factory.sin(Field<? extends Number> field)
Get the sine(field) function
This renders the sin function where available:
sin([field])
|
static Field<BigDecimal> |
Factory.sin(Number value)
Get the sine(field) function
|
static Field<BigDecimal> |
Factory.sinh(Field<? extends Number> field)
Get the hyperbolic sine function: sinh(field)
This renders the sinh function where available:
sinh([field]) ... or simulates it elsewhere using
exp: (exp([field] * 2) - 1) / (exp([field] * 2))
|
static Field<BigDecimal> |
Factory.sinh(Number value)
Get the hyperbolic sine function: sinh(field)
|
static Field<BigDecimal> |
Factory.sqrt(Field<? extends Number> field)
Get the sqrt(field) function
This renders the sqrt function where available:
sqrt([field]) ... or simulates it elsewhere using
power (which in turn may also be simulated using ln and exp functions):
power([field], 0.5)
|
static Field<BigDecimal> |
Factory.sqrt(Number value)
Get the sqrt(field) function
|
static AggregateFunction<BigDecimal> |
Factory.stddevPop(Field<? extends Number> field)
Get the population standard deviation of a numeric field: stddev_pop(field)
|
static AggregateFunction<BigDecimal> |
Factory.stddevSamp(Field<? extends Number> field)
Get the sample standard deviation of a numeric field: stddev_samp(field)
|
static Field<String> |
Factory.substring(Field<String> field,
Field<? extends Number> startingPosition)
Get the substring(field, startingPosition) function
This renders the substr or substring function:
substr([field], [startingPosition]) or
substring([field], [startingPosition])
|
static Field<String> |
Factory.substring(Field<String> field,
Field<? extends Number> startingPosition,
Field<? extends Number> length)
Get the substring(field, startingPosition, length) function
This renders the substr or substring function:
substr([field], [startingPosition], [length]) or
substring([field], [startingPosition], [length])
|
static Field<String> |
Factory.substring(Field<String> field,
int startingPosition)
Get the substring(field, startingPosition) function
|
static Field<String> |
Factory.substring(Field<String> field,
int startingPosition,
int length)
Get the substring(field, startingPosition, length) function
|
static AggregateFunction<BigDecimal> |
Factory.sum(Field<? extends Number> field)
Get the sum over a numeric field: sum(field)
|
static AggregateFunction<BigDecimal> |
Factory.sumDistinct(Field<? extends Number> field)
Get the sum over a numeric field: sum(distinct field)
|
static Field<String> |
Factory.sysConnectByPath(Field<?> field,
String separator)
Retrieve the Oracle-specific
SYS_CONNECT_BY_PATH(field, separator) function (to be used
along with CONNECT BY clauses).
|
static Table<?> |
Factory.table(ArrayRecord<?> array)
|
static Table<?> |
Factory.table(Field<?> cursor)
|
static Table<?> |
Factory.table(List<?> list)
|
static Table<?> |
Factory.table(Object[] array)
|
static Table<Record> |
Factory.table(String sql)
A custom SQL clause that can render arbitrary table expressions.
|
static Table<Record> |
Factory.table(String sql,
Object... bindings)
A custom SQL clause that can render arbitrary table expressions.
|
static Table<Record> |
Factory.table(String sql,
QueryPart... parts)
A custom SQL clause that can render arbitrary table expressions.
|
static Table<Record> |
Factory.tableByName(String... qualifiedName)
Create a qualified table, given its table name
This constructs a table reference given the table's qualified name. jOOQ
will render the table name according to your
Settings.getRenderNameStyle() settings.
|
static Field<BigDecimal> |
Factory.tan(Field<? extends Number> field)
Get the tangent(field) function
This renders the tan function where available:
tan([field])
|
static Field<BigDecimal> |
Factory.tan(Number value)
Get the tangent(field) function
|
static Field<BigDecimal> |
Factory.tanh(Field<? extends Number> field)
Get the hyperbolic tangent function: tanh(field)
This renders the tanh function where available:
tanh([field]) ... or simulates it elsewhere using
exp:
(exp([field] * 2) - 1) / (exp([field] * 2) + 1)
|
static Field<BigDecimal> |
Factory.tanh(Number value)
Get the hyperbolic tangent function: tanh(field)
|
static Field<Timestamp> |
Factory.timestampAdd(Field<Timestamp> timestamp,
Field<? extends Number> interval)
Add an interval to a timestamp
This translates into any dialect
|
static Field<Timestamp> |
Factory.timestampAdd(Timestamp timestamp,
Number interval)
Add an interval to a timestamp
This translates into any dialect
|
static Field<DayToSecond> |
Factory.timestampDiff(Field<Timestamp> timestamp1,
Field<Timestamp> timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
type
This translates into any dialect
|
static Field<DayToSecond> |
Factory.timestampDiff(Field<Timestamp> timestamp1,
Timestamp timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
type
This translates into any dialect
|
static Field<DayToSecond> |
Factory.timestampDiff(Timestamp timestamp1,
Field<Timestamp> timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
type
This translates into any dialect
|
static Field<DayToSecond> |
Factory.timestampDiff(Timestamp timestamp1,
Timestamp timestamp2)
Get the timestamp difference as a INTERVAL DAY TO SECOND
type
This translates into any dialect
|
static Field<String> |
Factory.trim(Field<String> field)
Get the trim(field) function
This renders the trim function where available:
trim([field]) ... or simulates it elsewhere using
rtrim and ltrim: ltrim(rtrim([field]))
|
static Field<String> |
Factory.trim(String value)
Get the trim(field) function
|
static Condition |
Factory.trueCondition()
Return a Condition that will always evaluate to true
|
static <T extends Number> Field<T> |
Factory.trunc(Field<T> number,
Field<Integer> decimals)
Truncate a number to a given number of decimals
This function truncates number to the amount of decimals
specified in decimals .
|
static <T extends Number> Field<T> |
Factory.trunc(Field<T> number,
int decimals)
Truncate a number to a given number of decimals
|
static <T extends Number> Field<T> |
Factory.trunc(T number)
Truncate a number to a given number of decimals
|
static <T extends Number> Field<T> |
Factory.trunc(T number,
Field<Integer> decimals)
Truncate a number to a given number of decimals
|
static <T extends Number> Field<T> |
Factory.trunc(T number,
int decimals)
Truncate a number to a given number of decimals
|
static Field<Integer> |
Factory.two()
A 2 literal.
|
static Table<?> |
Factory.unnest(ArrayRecord<?> array)
Create a table from an array of values
This wraps the argument array in a TABLE function for
Oracle.
|
static Table<?> |
Factory.unnest(Field<?> cursor)
Create a table from a field.
|
static Table<?> |
Factory.unnest(List<?> list)
Create a table from a list of values
This is equivalent to the TABLE function for H2, or the
UNNEST function in HSQLDB and Postgres
For Oracle, use Factory.table(ArrayRecord) instead, as Oracle knows only
typed arrays
In all other dialects, unnesting of arrays is simulated using several
UNION ALL connected subqueries.
|
static Table<?> |
Factory.unnest(Object[] array)
Create a table from an array of values
This is equivalent to the TABLE function for H2, or the
UNNEST function in HSQLDB and Postgres
For Oracle, use Factory.table(ArrayRecord) instead, as Oracle knows only
typed arrays
In all other dialects, unnesting of arrays is simulated using several
UNION ALL connected subqueries.
|
static Field<String> |
Factory.upper(Field<String> field)
Get the upper(field) function
This renders the upper function in all dialects:
upper([field])
|
static Field<String> |
Factory.upper(String value)
Get the upper(field) function
|
static <T> Field<T> |
Factory.val(Object value,
Class<? extends T> type)
Get a bind value with an associated type, taken from a field
|
static <T> Field<T> |
Factory.val(Object value,
DataType<T> type)
Get a bind value with an associated type
This will try to bind value as type in a
PreparedStatement .
|
static <T> Field<T> |
Factory.val(Object value,
Field<T> field)
Get a bind value with an associated type, taken from a field
|
static <T> Field<T> |
Factory.val(T value)
Get a bind value
jOOQ tries to derive the RDBMS DataType from the provided Java
type <T> .
|
static List<Field<?>> |
Factory.vals(Object... values)
Get a list of bind values and fields
|
static <T> Field<T> |
Factory.value(Object value,
Class<? extends T> type)
|
static <T> Field<T> |
Factory.value(Object value,
DataType<T> type)
|
static <T> Field<T> |
Factory.value(Object value,
Field<T> field)
|
static <T> Field<T> |
Factory.value(T value)
A synonym for Factory.val(Object) to be used in Scala and Groovy, where
val is a reserved keyword.
|
static AggregateFunction<BigDecimal> |
Factory.varPop(Field<? extends Number> field)
Get the population variance of a numeric field: var_pop(field)
|
static AggregateFunction<BigDecimal> |
Factory.varSamp(Field<? extends Number> field)
Get the sample variance of a numeric field: var_samp(field)
|
static Field<Integer> |
Factory.year(Date value)
|
static Field<Integer> |
Factory.year(Field<? extends Date> field)
|
static Field<Integer> |
Factory.zero()
A 0 literal.
|
Methods in org.jooq.util.oracle with annotations of type Support
Modifier and Type |
Method and Description |
static Field<BigDecimal> |
OracleFactory.catsearch(Field<String> field,
String textQuery,
String structuredQuery)
The Oracle-Text specific CATSEARCH function
|
static Field<BigDecimal> |
OracleFactory.contains(Field<String> field,
String query)
The Oracle-Text specific CONTAINS function
|
static Field<BigDecimal> |
OracleFactory.contains(Field<String> field,
String query,
int label)
The Oracle-Text specific CONTAINS function
|
static Field<BigDecimal> |
OracleFactory.matches(Field<String> field,
String query)
The Oracle-Text specific MATCHES function
|
static Field<BigDecimal> |
OracleFactory.matches(Field<String> field,
String query,
int label)
The Oracle-Text specific CONTAINS function
|
static Field<BigDecimal> |
OracleFactory.matchScore(int label)
The Oracle-Text specific MATCH_SCORE function
|
static Field<String> |
OracleFactory.rowid()
Retrieve the Oracle-specific ROWID pseudo-field
|
static Field<Integer> |
OracleFactory.rownum()
Retrieve the Oracle-specific ROWNUM pseudo-field
|
static Field<BigDecimal> |
OracleFactory.score(int label)
The Oracle-Text specific SCORE function
|
static Field<String> |
OracleFactory.sysContext(String namespace,
String parameter)
The Oracle-specific SYS_CONTEXT function
|
static Field<String> |
OracleFactory.sysContext(String namespace,
String parameter,
int length)
The Oracle-specific SYS_CONTEXT function
|
Copyright © 2013. All Rights Reserved.
|