Package | Description |
---|---|
org.jooq |
The
org.jooq package contains jOOQ's public API
This package mostly contains interfaces that are implemented by the
org.jooq.impl package. |
org.jooq.impl |
The
org.jooq.impl package contains jOOQ's implementation classes
This package provides implementations for the jOOQ API from
org.jooq , whose interfaces are constructed mostly through the
Factory class, which hides implementation facts from
the public API |
org.jooq.util.cubrid |
The
org.jooq.util.ase package contains classes related to the
SQLDialect.ASE dialect |
org.jooq.util.mysql |
The
org.jooq.util.ase package contains classes related to the
SQLDialect.ORACLE dialect |
org.jooq.util.oracle |
The
org.jooq.util.ase package contains classes related to the
SQLDialect.MYSQL dialect |
org.jooq.util.sqlite |
The
org.jooq.util.ase package contains classes related to the
SQLDialect.SQLITE dialect |
Modifier and Type | Interface and Description |
---|---|
interface |
AggregateFunction<T>
An aggregate function is a special field that is usually used in a
GROUP BY context. |
interface |
CaseConditionStep<T>
The final step in creating a case statement of the type
CASE WHEN x < 1 THEN 'one'
WHEN x >= 2 THEN 'two'
ELSE 'three'
END
|
interface |
CaseWhenStep<V,T>
The final step in creating a case statement of the type
CASE x WHEN 1 THEN 'one'
WHEN 2 THEN 'two'
ELSE 'three'
END
|
interface |
GroupConcatOrderByStep
MySQL's
GROUP_CONCAT function. |
interface |
GroupConcatSeparatorStep
MySQL's
GROUP_CONCAT function. |
interface |
Param<T>
A named parameter and/or bind value.
|
interface |
TableField<R extends Record,T>
A field contained in a table
|
interface |
UDTField<R extends UDTRecord<R>,T>
A field contained in a UDT
|
interface |
WindowBeforeOverStep<T>
This type is used for the window function DSL API.
|
interface |
WindowFinalStep<T>
This type is used for the window function DSL API.
|
interface |
WindowOrderByStep<T>
This type is used for the window function DSL API.
|
interface |
WindowPartitionByStep<T>
This type is used for the window function DSL API.
|
interface |
WindowRowsStep<T>
This type is used for the window function DSL API.
|
Modifier and Type | Method and Description |
---|---|
Field<T> |
Field.abs()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.acos()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.add(Field<?> value)
An arithmetic expression to add value to this.
|
Field<T> |
Field.add(Number value)
An arithmetic expression adding this to value.
|
Field<T> |
Field.as(String alias)
Create an alias for this field
|
Field<Integer> |
Field.ascii()
This method is part of the pre-2.0 API.
|
<T> Field<T> |
FieldLike.asField()
The underlying field representation of this object
This method is useful for things like
SELECT y.*, (SELECT a FROM x) FROM y |
<T> Field<T> |
FieldLike.asField(String alias)
The underlying field representation of this object
This method is useful for things like
SELECT y.*, (SELECT a FROM x) [alias] FROM y |
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.
|
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.
|
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.
|
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.
|
Field<T> |
Sequence.currval()
Get the current value of this sequence
|
<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.
|
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.
|
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.
|
Field<T1> |
Row8.field1()
Get the first field
|
Field<T1> |
Row7.field1()
Get the first field
|
Field<T1> |
Row6.field1()
Get the first field
|
Field<T1> |
Row5.field1()
Get the first field
|
Field<T1> |
Row4.field1()
Get the first field
|
Field<T1> |
Row3.field1()
Get the first field
|
Field<T1> |
Row2.field1()
Get the first field
|
Field<T1> |
Row1.field1()
Get the first field
|
Field<T2> |
Row8.field2()
Get the second field
|
Field<T2> |
Row7.field2()
Get the second field
|
Field<T2> |
Row6.field2()
Get the second field
|
Field<T2> |
Row5.field2()
Get the second field
|
Field<T2> |
Row4.field2()
Get the second field
|
Field<T2> |
Row3.field2()
Get the second field
|
Field<T2> |
Row2.field2()
Get the second field
|
Field<T3> |
Row8.field3()
Get the third field
|
Field<T3> |
Row7.field3()
Get the third field
|
Field<T3> |
Row6.field3()
Get the third field
|
Field<T3> |
Row5.field3()
Get the third field
|
Field<T3> |
Row4.field3()
Get the third field
|
Field<T3> |
Row3.field3()
Get the third field
|
Field<T4> |
Row8.field4()
Get the fourth field
|
Field<T4> |
Row7.field4()
Get the fourth field
|
Field<T4> |
Row6.field4()
Get the fourth field
|
Field<T4> |
Row5.field4()
Get the fourth field
|
Field<T4> |
Row4.field4()
Get the fourth field
|
Field<T5> |
Row8.field5()
Get the fifth field
|
Field<T5> |
Row7.field5()
Get the fifth field
|
Field<T5> |
Row6.field5()
Get the fifth field
|
Field<T5> |
Row5.field5()
Get the fifth field
|
Field<T6> |
Row8.field6()
Get the sixth field
|
Field<T6> |
Row7.field6()
Get the sixth field
|
Field<T6> |
Row6.field6()
Get the sixth field
|
Field<T7> |
Row8.field7()
Get the seventh field
|
Field<T7> |
Row7.field7()
Get the seventh field
|
Field<T8> |
Row8.field8()
Get the eight field
|
Field<T> |
Field.floor()
This method is part of the pre-2.0 API.
|
<T> Field<T> |
FieldProvider.getField(Field<T> field)
Get a specific field from this field provider.
|
Field<?> |
Row.getField(int index)
Get a field at a given index
|
Field<?> |
FieldProvider.getField(int index)
Get a specific field from this field provider.
|
Field<?> |
FieldProvider.getField(String name)
Get a specific field from this field provider.
|
Field<?>[] |
Row.getFields()
Get all fields of this row value expression
|
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.
|
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.
|
Field<Integer> |
Field.length()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.ln()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.log(int base)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lower()
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(Field<? extends Number> length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(Field<? extends Number> length,
Field<String> character)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(int length)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.lpad(int length,
char character)
This method is part of the pre-2.0 API.
|
Field<String> |
Field.ltrim()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.max()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.median()
This method is part of the pre-2.0 API.
|
Field<T> |
Field.min()
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.
|
Field<T> |
Field.neg()
Negate this field to get its negative value.
|
Field<T> |
Sequence.nextval()
Increment the sequence and get the next value
|
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.
|
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.
|
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
|
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.
|
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.
|
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.
|
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.
|
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.
|
Field<BigDecimal> |
Field.sqrt()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.stddevPop()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.stddevSamp()
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.
|
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.
|
Field<String> |
Field.upper()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.varPop()
This method is part of the pre-2.0 API.
|
Field<BigDecimal> |
Field.varSamp()
This method is part of the pre-2.0 API.
|
Modifier and Type | Method and Description |
---|---|
List<Field<?>> |
FieldProvider.getFields() |
List<Field<?>> |
Select.getSelect()
All fields selected in this query
|
Modifier and Type | Method and Description |
---|---|
Field<T> |
Field.add(Field<?> value)
An arithmetic expression to add value to this.
|
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.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 |
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 |
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,
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> |
StoreQuery.addValueAsArray(Field<A> field,
List<T> value)
Add a value to the store statement
|
<A extends ArrayRecord<T>,T> |
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,
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. |
Condition |
BetweenAndStep.and(Field<T> field)
Create a condition to check this field against some bounds
|
Field<BigDecimal> |
Field.atan2(Field<? extends Number> y)
This method is part of the pre-2.0 API.
|
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 |
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.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 |
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 |
<Z> Field<Z> |
Field.cast(Field<Z> field)
Cast this field to the type of another field.
|
Field<T> |
Field.coalesce(Field<T> option,
Field<?>... options)
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.
|
Condition |
Field.compare(Comparator comparator,
Field<T> field)
Compare this field with another field using a dynamic comparator
|
Field<String> |
Field.concat(Field<?>... fields)
This method is part of the pre-2.0 API.
|
Condition |
Field.contains(Field<T> value)
Convenience method for
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. |
<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)
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(Field<T> search,
Field<Z> result,
Field<?>... more)
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.
|
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.
|
Condition |
Field.endsWith(Field<T> value)
Convenience method for
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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.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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
Field.equalAll(Field<T[]> array)
this = all (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.equalAny(Field<T[]> array)
this = any (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.equalIgnoreCase(Field<String> value)
lower(this) = lower(value) |
<T> List<T> |
ResultQuery.fetch(Field<?> field,
Class<? extends T> type)
Execute the query and return all values for a field from the generated
result.
|
<T> List<T> |
ResultQuery.fetch(Field<T> field)
Execute the query and return all values for a field from the generated
result.
|
<T,U> List<U> |
ResultQuery.fetch(Field<T> field,
Converter<? super T,U> converter)
Execute the query and return all values for a field from the generated
result.
|
<Z> List<P> |
DAO.fetch(Field<Z> field,
Z... values)
Find records by a given field and a set of values.
|
<T> T[] |
ResultQuery.fetchArray(Field<?> field,
Class<? extends T> type)
Execute the query and return all values for a field from the generated
result.
|
<T> T[] |
ResultQuery.fetchArray(Field<T> field)
Execute the query and return all values for a field from the generated
result.
|
<T,U> U[] |
ResultQuery.fetchArray(Field<T> field,
Converter<? super T,U> converter)
Execute the query and return all values for a field from the generated
result.
|
Map<Record,Result<R>> |
ResultQuery.fetchGroups(Field<?>[] keys)
Execute the query and return a
Map with the result grouped by the
given keys. |
<E> Map<Record,List<E>> |
ResultQuery.fetchGroups(Field<?>[] keys,
Class<? extends E> type)
Execute the query and return a
Map with results grouped by the
given keys and mapped into the given entity type. |
<K> Map<K,Result<R>> |
ResultQuery.fetchGroups(Field<K> key)
Execute the query and return a
Map with one of the result's
columns as key and a list of corresponding records as value. |
<K,E> Map<K,List<E>> |
ResultQuery.fetchGroups(Field<K> key,
Class<? extends E> type)
Return a
Map with results grouped by the given key and mapped
into the given entity type. |
<K,V> Map<K,List<V>> |
ResultQuery.fetchGroups(Field<K> key,
Field<V> value)
Execute the query and return a
Map with one of the result's
columns as key and another one of the result's columns as value
Unlike ResultQuery.fetchMap(Field, Field) , this method allows for non-unique
keys in the result set. |
<K,V> Map<K,List<V>> |
ResultQuery.fetchGroups(Field<K> key,
Field<V> value)
Execute the query and return a
Map with one of the result's
columns as key and another one of the result's columns as value
Unlike ResultQuery.fetchMap(Field, Field) , this method allows for non-unique
keys in the result set. |
Map<Record,R> |
ResultQuery.fetchMap(Field<?>[] keys)
Execute the query and return a
Map with keys as a map key and the
corresponding record as value. |
<E> Map<List<?>,E> |
ResultQuery.fetchMap(Field<?>[] keys,
Class<? extends E> type)
Execute the query and return a
Map with results grouped by the
given keys and mapped into the given entity type. |
<K> Map<K,R> |
ResultQuery.fetchMap(Field<K> key)
Execute the query and return a
Map with one of the result's
columns as key and the corresponding records as value. |
<K,E> Map<K,E> |
ResultQuery.fetchMap(Field<K> key,
Class<? extends E> type)
Execute the query and return a
Map with results grouped by the
given key and mapped into the given entity type. |
<K,V> Map<K,V> |
ResultQuery.fetchMap(Field<K> key,
Field<V> value)
Execute the query and return a
Map with one of the result's
columns as key and another one of the result's columns as value
An exception is thrown, if the key turns out to be non-unique in the
result set. |
<K,V> Map<K,V> |
ResultQuery.fetchMap(Field<K> key,
Field<V> value)
Execute the query and return a
Map with one of the result's
columns as key and another one of the result's columns as value
An exception is thrown, if the key turns out to be non-unique in the
result set. |
<T> T |
ResultQuery.fetchOne(Field<?> field,
Class<? extends T> type)
Execute the query and return return at most one resulting value for a
field from the generated result.
|
<T> T |
ResultQuery.fetchOne(Field<T> field)
Execute the query and return return at most one resulting value for a
field from the generated result.
|
<T,U> U |
ResultQuery.fetchOne(Field<T> field,
Converter<? super T,U> converter)
Execute the query and return return at most one resulting value for a
field from the generated result.
|
<Z> P |
DAO.fetchOne(Field<Z> field,
Z value)
Find a unique record by a given field and a value.
|
LoaderCSVOptionsStep<R> |
LoaderCSVStep.fields(Field<?>... fields)
Specify the the fields to be loaded into the table in the correct order.
|
Condition |
Field.ge(Field<T> field)
this >= field |
<T> Field<T> |
FieldProvider.getField(Field<T> field)
Get a specific field from this field provider.
|
int |
FieldProvider.getIndex(Field<?> field)
Get a fields index from this field provider
|
<T> T |
Record.getValue(Field<?> field,
Class<? extends T> type)
Get a converted value from this Record, providing a field.
|
<T> T |
Record.getValue(Field<?> field,
Class<? extends T> type,
T defaultValue)
Get a converted value from this record, providing a field.
|
<T> T |
Record.getValue(Field<T> field)
Get a value from this Record, providing a field.
|
<T,U> U |
Record.getValue(Field<T> field,
Converter<? super T,U> converter)
Get a converted value from this Record, providing a field.
|
<T,U> U |
Record.getValue(Field<T> field,
Converter<? super T,U> converter,
U defaultValue)
Get a converted value from this record, providing a field.
|
<T> T |
Record.getValue(Field<T> field,
T defaultValue)
Get a value from this record, providing a field.
|
<T> T |
Result.getValue(int index,
Field<T> field)
Convenience method to fetch a value at a given position in the result.
|
<T> T |
Result.getValue(int index,
Field<T> field,
T defaultValue)
Convenience method to fetch a value at a given position in the result.
|
<A extends ArrayRecord<T>,T> |
Record.getValueAsArray(Field<A> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse
|
<A extends ArrayRecord<T>,T> |
Record.getValueAsArray(Field<A> field,
T[] defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse
|
<A extends ArrayRecord<T>,T> |
Result.getValueAsArray(int index,
Field<A> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse
|
<A extends ArrayRecord<T>,T> |
Result.getValueAsArray(int index,
Field<A> field,
T[] defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse
|
BigDecimal |
Record.getValueAsBigDecimal(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
BigDecimal |
Record.getValueAsBigDecimal(Field<?> field,
BigDecimal defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
BigDecimal |
Result.getValueAsBigDecimal(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
BigDecimal |
Result.getValueAsBigDecimal(int index,
Field<?> field,
BigDecimal defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
BigInteger |
Record.getValueAsBigInteger(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
BigInteger |
Record.getValueAsBigInteger(Field<?> field,
BigInteger defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
BigInteger |
Result.getValueAsBigInteger(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
BigInteger |
Result.getValueAsBigInteger(int index,
Field<?> field,
BigInteger defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Boolean |
Record.getValueAsBoolean(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Boolean |
Record.getValueAsBoolean(Field<?> field,
Boolean defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Boolean |
Result.getValueAsBoolean(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Boolean |
Result.getValueAsBoolean(int index,
Field<?> field,
Boolean defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Byte |
Record.getValueAsByte(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Byte |
Record.getValueAsByte(Field<?> field,
Byte defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Byte |
Result.getValueAsByte(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Byte |
Result.getValueAsByte(int index,
Field<?> field,
Byte defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Date |
Record.getValueAsDate(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Date |
Record.getValueAsDate(Field<?> field,
Date defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Date |
Result.getValueAsDate(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Date |
Result.getValueAsDate(int index,
Field<?> field,
Date defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Double |
Record.getValueAsDouble(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Double |
Record.getValueAsDouble(Field<?> field,
Double defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Double |
Result.getValueAsDouble(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Double |
Result.getValueAsDouble(int index,
Field<?> field,
Double defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Float |
Record.getValueAsFloat(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Float |
Record.getValueAsFloat(Field<?> field,
Float defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Float |
Result.getValueAsFloat(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Float |
Result.getValueAsFloat(int index,
Field<?> field,
Float defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Integer |
Record.getValueAsInteger(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Integer |
Record.getValueAsInteger(Field<?> field,
Integer defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Integer |
Result.getValueAsInteger(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Integer |
Result.getValueAsInteger(int index,
Field<?> field,
Integer defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Long |
Record.getValueAsLong(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Long |
Record.getValueAsLong(Field<?> field,
Long defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Long |
Result.getValueAsLong(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Long |
Result.getValueAsLong(int index,
Field<?> field,
Long defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Short |
Record.getValueAsShort(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Short |
Record.getValueAsShort(Field<?> field,
Short defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Short |
Result.getValueAsShort(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Short |
Result.getValueAsShort(int index,
Field<?> field,
Short defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
String |
Record.getValueAsString(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
String |
Record.getValueAsString(Field<?> field,
String defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
String |
Result.getValueAsString(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
String |
Result.getValueAsString(int index,
Field<?> field,
String defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Time |
Record.getValueAsTime(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Time |
Record.getValueAsTime(Field<?> field,
Time defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Time |
Result.getValueAsTime(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Time |
Result.getValueAsTime(int index,
Field<?> field,
Time defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Timestamp |
Record.getValueAsTimestamp(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Timestamp |
Record.getValueAsTimestamp(Field<?> field,
Timestamp defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class)
instead. |
Timestamp |
Result.getValueAsTimestamp(int index,
Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
Timestamp |
Result.getValueAsTimestamp(int index,
Field<?> field,
Timestamp defaultValue)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Record.getValue(Field, Class) instead. |
<T> List<T> |
Result.getValues(Field<?> field,
Class<? extends T> type)
Convenience method to fetch all values for a given field.
|
<T> List<T> |
Result.getValues(Field<T> field)
Convenience method to fetch all values for a given field.
|
<T,U> List<U> |
Result.getValues(Field<T> field,
Converter<? super T,U> converter)
Convenience method to fetch all values for a given field.
|
List<BigDecimal> |
Result.getValuesAsBigDecimal(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<BigInteger> |
Result.getValuesAsBigInteger(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Byte> |
Result.getValuesAsByte(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Date> |
Result.getValuesAsDate(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Double> |
Result.getValuesAsDouble(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Float> |
Result.getValuesAsFloat(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Integer> |
Result.getValuesAsInteger(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Long> |
Result.getValuesAsLong(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Short> |
Result.getValuesAsShort(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<String> |
Result.getValuesAsString(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Time> |
Result.getValuesAsTime(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
List<Timestamp> |
Result.getValuesAsTimestamp(Field<?> field)
Deprecated.
- 2.6.0 [#1839] - These methods will be removed in the
future. Do not reuse. Use
Result.getValues(Field, Class)
instead. |
Condition |
Field.greaterOrEqual(Field<T> field)
this >= field |
Condition |
Field.greaterOrEqualAll(Field<T[]> array)
this >= all (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.greaterOrEqualAny(Field<T[]> array)
this >= any (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.greaterThan(Field<T> field)
this > field |
Condition |
Field.greaterThanAll(Field<T[]> array)
this > all (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.greaterThanAny(Field<T[]> array)
this > any (array)
This is natively supported by SQLDialect.POSTGRES . |
Field<T> |
Field.greatest(Field<?>... others)
This method is part of the pre-2.0 API.
|
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 |
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...) |
<R extends Record> |
FactoryOperations.insertInto(Table<R> into,
Field<?>... fields)
Create a new DSL insert statement.
|
<T> T[] |
Result.intoArray(Field<?> field,
Class<? extends T> type)
Return all values for a field from the result.
|
<T> T[] |
Result.intoArray(Field<T> field)
Return all values for a field from the result.
|
<T,U> U[] |
Result.intoArray(Field<T> field,
Converter<? super T,U> converter)
Return all values for a field from the result.
|
Map<Record,Result<R>> |
Result.intoGroups(Field<?>[] keys)
Return a
Map with the result grouped by the given keys. |
<E> Map<Record,List<E>> |
Result.intoGroups(Field<?>[] keys,
Class<? extends E> type)
Return a
Map with results grouped by the given keys and mapped
into the given entity type. |
<K> Map<K,Result<R>> |
Result.intoGroups(Field<K> key)
Return a
Map with one of the result's columns as key and a list
of corresponding records as value. |
<K,E> Map<K,List<E>> |
Result.intoGroups(Field<K> key,
Class<? extends E> type)
Return a
Map with results grouped by the given key and mapped
into the given entity type. |
<K,V> Map<K,List<V>> |
Result.intoGroups(Field<K> key,
Field<V> value)
Return a
Map with one of the result's columns as key and another
one of the result's columns as value
Unlike Result.intoMap(Field, Field) , this method allows for non-unique
keys in the result set. |
<K,V> Map<K,List<V>> |
Result.intoGroups(Field<K> key,
Field<V> value)
Return a
Map with one of the result's columns as key and another
one of the result's columns as value
Unlike Result.intoMap(Field, Field) , this method allows for non-unique
keys in the result set. |
Map<Record,R> |
Result.intoMap(Field<?>[] keys)
Return a
Map with the given keys as a map key and the
corresponding record as value. |
<E> Map<List<?>,E> |
Result.intoMap(Field<?>[] keys,
Class<? extends E> type)
Return a
Map with results grouped by the given keys and mapped
into the given entity type. |
<K> Map<K,R> |
Result.intoMap(Field<K> key)
Return a
Map with one of the result's columns as key and the
corresponding records as value. |
<K,E> Map<K,E> |
Result.intoMap(Field<K> key,
Class<? extends E> type)
Return a
Map with results grouped by the given key and mapped
into the given entity type. |
<K,V> Map<K,V> |
Result.intoMap(Field<K> key,
Field<V> value)
Return a
Map with one of the result's columns as key and another
one of the result's columns as value
An InvalidResultException is thrown, if the key turns out to be
non-unique in the result set. |
<K,V> Map<K,V> |
Result.intoMap(Field<K> key,
Field<V> value)
Return a
Map with one of the result's columns as key and another
one of the result's columns as value
An InvalidResultException is thrown, if the key turns out to be
non-unique in the result set. |
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.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 |
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.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. |
MergeValuesStep<R> |
MergeKeyStep.key(Field<?>... keys)
Specify an optional
KEY clause. |
WindowIgnoreNullsStep<T> |
Field.lag(int offset,
Field<T> defaultValue)
This method is part of the pre-2.0 API.
|
Condition |
Field.le(Field<T> field)
this <= field |
WindowIgnoreNullsStep<T> |
Field.lead(int offset,
Field<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.
|
Condition |
Field.lessOrEqual(Field<T> field)
this <= field |
Condition |
Field.lessOrEqualAll(Field<T[]> array)
this <= all (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.lessOrEqualAny(Field<T[]> array)
this <= any (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.lessThan(Field<T> field)
this < field |
Condition |
Field.lessThanAll(Field<T[]> array)
this < all (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.lessThanAny(Field<T[]> array)
this < any (array)
This is natively supported by SQLDialect.POSTGRES . |
Condition |
Field.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.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.likeRegex(Field<String> pattern)
Create a condition to regex-pattern-check this field against a pattern
See
likeRegex(String) for more details |
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(Field<? extends Number> length,
Field<String> character)
This method is part of the pre-2.0 API.
|
Condition |
Field.lt(Field<T> field)
this < field |
<R extends Record> |
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.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.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.
|
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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) |
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 |
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.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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
Field.notEqualAll(Field<T[]> array)
this ! |
Condition |
Field.notEqualAny(Field<T[]> array)
this ! |
Condition |
Field.notEqualIgnoreCase(Field<String> value)
lower(this) ! |
Condition |
Field.notIn(Field<?>... values)
Create a condition to check this field against several values
Note that if any of the passed values is
NULL , then the
condition will be NULL (or false , depending on
the dialect) as well. |
Condition |
Field.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.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.notLikeRegex(Field<String> pattern)
Create a condition to regex-pattern-check this field against a pattern
See
likeRegex(String) for more details |
Field<T> |
Field.nullif(Field<T> other)
This method is part of the pre-2.0 API.
|
Field<T> |
Field.nvl(Field<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(Field<Z> valueIfNotNull,
Field<Z> valueIfNull)
This method is part of the pre-2.0 API.
|
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. |
<T> PivotInStep<T> |
PivotForStep.on(Field<T> field)
Add a list of fields to the
PIVOT clause. |
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.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. |
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
|
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(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)
|
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 |
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<String> |
Field.repeat(Field<? extends 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(Field<String> search,
Field<String> replace)
This method is part of the pre-2.0 API.
|
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
|
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(Field<? extends Number> length,
Field<String> character)
This method is part of the pre-2.0 API.
|
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.
|
SelectSelectStep |
FactoryOperations.selectDistinct(Field<?>... fields)
Create a new DSL select statement.
|
<T> UpdateSetMoreStep<R> |
UpdateSetStep.set(Field<T> field,
Field<T> value)
Set a value for a field in the
UPDATE statement |
<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> 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> 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> 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> 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 |
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 |
InsertQuery.setReturning(Field<?>... fields)
Configure the
INSERT statement to return a list of fields in
R . |
<T> void |
Record.setValue(Field<T> field,
T value)
Set a value into this record.
|
<T,U> void |
Record.setValue(Field<T> field,
U value,
Converter<T,? super U> converter)
Set a value into this record.
|
<T extends Comparable<? super T>> |
Result.sortAsc(Field<T> field)
Sort this result by one of its contained fields.
|
<T> Result<R> |
Result.sortAsc(Field<T> field,
Comparator<? super T> comparator)
Sort this result by one of its contained fields using a comparator.
|
<T extends Comparable<? super T>> |
Result.sortDesc(Field<T> field)
Reverse-sort this result by one of its contained fields.
|
<T> Result<R> |
Result.sortDesc(Field<T> field,
Comparator<? super T> comparator)
Reverse-sort this result by one of its contained fields using a
comparator.
|
Condition |
Field.startsWith(Field<T> value)
Convenience method for
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) |
Field<T> |
Field.sub(Field<?> 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(Field<? extends Number> startingPosition,
Field<? extends Number> length)
This method is part of the pre-2.0 API.
|
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...]) |
<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
|
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
|
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 |
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.
|
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.
|
<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.
|
MergeNotMatchedValuesStep<R> |
MergeNotMatchedStep.whenNotMatchedThenInsert(Field<?>... fields)
Add the
WHEN NOT MATCHED THEN INSERT clause to the
MERGE statement |
AggregateFunction<T> |
OrderedAggregateFunction.withinGroupOrderBy(Field<?>... fields)
Add an
WITHIN GROUP (ORDER BY ..) |
Modifier and Type | Method and Description |
---|---|
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.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 |
SelectQuery.addSelect(Collection<? extends Field<?>> fields)
Add a list of select fields
|
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. |
LoaderCSVOptionsStep<R> |
LoaderCSVStep.fields(Collection<? extends Field<?>> fields)
Specify the the fields to be loaded into the table in the correct order.
|
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. |
Table<Record> |
PivotInStep.in(Collection<? extends Field<T>> fields)
Specify the acceptable values for pivoting
This clause is generally only supported by
SQLDialect.ORACLE . |
<R extends Record> |
FactoryOperations.insertInto(Table<R> into,
Collection<? extends Field<?>> fields)
Create a new DSL insert statement.
|
MergeValuesStep<R> |
MergeKeyStep.key(Collection<? extends Field<?>> keys)
Specify an optional
KEY clause. |
<R extends Record> |
FactoryOperations.mergeInto(Table<R> table,
Collection<? extends Field<?>> fields)
Create a new DSL merge statement (H2-specific syntax)
|
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. |
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 |
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...) |
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
|
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 |
FactoryOperations.selectDistinct(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
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 |
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 |
InsertQuery.setReturning(Collection<? extends Field<?>> fields)
Configure the
INSERT statement to return a list of fields in
R . |
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...]) |
MergeNotMatchedValuesStep<R> |
MergeNotMatchedStep.whenNotMatchedThenInsert(Collection<? extends Field<?>> fields)
Add the
WHEN MATCHED THEN UPDATE clause to the
MERGE statement |
Modifier and Type | Class and Description |
---|---|
class |
CustomField<T>
A base class for custom
Field implementations in client code. |
Modifier and Type | Method and Description |
---|---|
static <T extends Number> |
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> |
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
|
Field<T> |
CustomField.add(Field<?> value) |
Field<T> |
CustomField.as(String alias) |
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
|
Field<T> |
AbstractRoutine.asField() |
Field<T> |
AbstractRoutine.asField(String alias) |
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 <T extends Number> |
Factory.bitAnd(Field<T> field1,
Field<T> field2)
The bitwise and operator.
|
static <T extends Number> |
Factory.bitAnd(Field<T> value1,
T value2)
The bitwise and operator.
|
static <T extends Number> |
Factory.bitAnd(T value1,
Field<T> value2)
The bitwise and operator.
|
static <T extends Number> |
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> |
Factory.bitNand(Field<T> field1,
Field<T> field2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNand(Field<T> value1,
T value2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNand(T value1,
Field<T> value2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNand(T value1,
T value2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNor(Field<T> field1,
Field<T> field2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNor(Field<T> value1,
T value2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNor(T value1,
Field<T> value2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNor(T value1,
T value2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNot(Field<T> field)
The bitwise not operator.
|
static <T extends Number> |
Factory.bitNot(T value)
The bitwise not operator.
|
static <T extends Number> |
Factory.bitOr(Field<T> field1,
Field<T> field2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitOr(Field<T> value1,
T value2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitOr(T value1,
Field<T> value2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitOr(T value1,
T value2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitXNor(Field<T> field1,
Field<T> field2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXNor(Field<T> value1,
T value2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXNor(T value1,
Field<T> value2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXNor(T value1,
T value2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXor(Field<T> field1,
Field<T> field2)
The bitwise xor operator.
|
static <T extends Number> |
Factory.bitXor(Field<T> value1,
T value2)
The bitwise xor operator.
|
static <T extends Number> |
Factory.bitXor(T value1,
Field<T> value2)
The bitwise xor operator.
|
static <T extends Number> |
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> |
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> |
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 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 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 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
|
Field<T> |
SequenceImpl.currval() |
static Field<Date> |
Factory.dateAdd(Date date,
Number interval)
Add an interval to a date
This translates into any dialect
|
static Field<Date> |
Factory.dateAdd(Field<Date> date,
Field<? extends Number> interval)
Add an interval to a date
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Date date1,
Date date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Date date1,
Field<Date> date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Field<Date> date1,
Date date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.dateDiff(Field<Date> date1,
Field<Date> date2)
Get the date difference in number of days
This translates into any dialect
|
static Field<Integer> |
Factory.day(Date value)
Get the day part of a date
This is the same as calling
Factory.extract(java.util.Date, DatePart)
with DatePart.DAY |
static Field<Integer> |
Factory.day(Field<? extends Date> field)
Get the day part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.DAY |
static <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 Field<BigDecimal> |
Factory.e()
The
E literal (Euler number)
This will be any of the following:
The underlying RDBMS' E literal or E() function
Math.E
|
static Field<String> |
Factory.escape(Field<String> field,
char escape)
Convenience method for
Factory.replace(Field, String, String) to escape
data for use with like(Field, char)
Essentially, this escapes % and _ characters |
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 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,
Class<T> type,
QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.
|
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 <T> Field<T> |
Factory.field(String sql,
DataType<T> type,
QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.
|
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 Field<Object> |
Factory.field(String sql,
QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.
|
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 extends Number> |
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> |
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> 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 Field<Integer> |
Factory.grouping(Field<?> field)
Create a GROUPING(field) aggregation field to be used along with
CUBE , ROLLUP , and GROUPING SETS
groupings
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
|
static Field<Integer> |
Factory.groupingId(Field<?>... fields)
Create a GROUPING_ID(field1, field2, .., fieldn) aggregation field to be
used along with
CUBE , ROLLUP , and
GROUPING SETS groupings
This has been observed to work with the following databases:
Oracle
SQL Server
|
static Field<?> |
Factory.groupingSets(Collection<Field<?>>... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna,
fieldnb)) grouping field
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of
CUBE , ROLLUP , and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx |
static Field<?> |
Factory.groupingSets(Field<?>... fields)
Create a GROUPING SETS(field1, field2, .., fieldn) grouping field where
each grouping set only consists of a single field.
|
static Field<?> |
Factory.groupingSets(Field<?>[]... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna,
fieldnb)) grouping field
This has been observed to work with the following databases:
DB2
Oracle
SQL Server
Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of
CUBE , ROLLUP , and GROUPING SETS
clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx |
static Field<Integer> |
Factory.hour(Date value)
Get the hour part of a date
This is the same as calling
Factory.extract(java.util.Date, DatePart)
with DatePart.HOUR |
static Field<Integer> |
Factory.hour(Field<? extends Date> field)
Get the hour part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.HOUR |
static <T> 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 <T> Field<T> |
Factory.literal(Object literal,
Class<T> type)
Deprecated.
- 2.3.0 - Use
Factory.field(String, Class) , or
Factory.inline(Object, Class) instead. |
static <T> Field<T> |
Factory.literal(Object literal,
DataType<T> type)
Deprecated.
- 2.3.0 - Use
Factory.field(String, DataType) , or
Factory.inline(Object, DataType) instead. |
static <T> Field<T> |
Factory.literal(T literal)
Deprecated.
- 2.3.0 - Use
Factory.field(String) , or
Factory.inline(Object) instead. |
static Field<BigDecimal> |
Factory.ln(Field<? extends Number> field)
Get the ln(field) function, taking the natural logarithm of this field
This renders the ln or log function where available:
ln([field]) or
log([field]) |
static Field<BigDecimal> |
Factory.ln(Number value)
Get the ln(field) function, taking the natural logarithm of this field
|
static Field<BigDecimal> |
Factory.log(Field<? extends Number> field,
int base)
Get the log(field, base) function
This renders the log function where available:
log([field]) ... or simulates it elsewhere (in
most RDBMS) using the natural logarithm:
ln([field]) / ln([base]) |
static Field<BigDecimal> |
Factory.log(Number value,
int base)
Get the log(field, base) function
|
static Field<String> |
Factory.lower(Field<String> value)
Get the lower(field) function
This renders the lower function in all dialects:
lower([field]) |
static Field<String> |
Factory.lower(String value)
Get the lower(field) function
|
static Field<String> |
Factory.lpad(Field<String> field,
Field<? extends Number> length)
Get the lpad(field, length) function
This renders the lpad function where available:
lpad([field], [length]) ... or simulates it
elsewhere using concat, repeat, and length, which may be simulated as
well, depending on the RDBMS:
concat(repeat(' ', [length] - length([field])), [field]) |
static Field<String> |
Factory.lpad(Field<String> field,
Field<? extends Number> length,
Field<String> character)
Get the lpad(field, length, character) function
This renders the lpad function where available:
lpad([field], [length]) ... or simulates it
elsewhere using concat, repeat, and length, which may be simulated as
well, depending on the RDBMS:
concat(repeat([character], [length] - length([field])), [field])
In SQLDialect.SQLITE , this is simulated as such:
replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '''', ''), '0', [character]) || [field] |
static Field<String> |
Factory.lpad(Field<String> field,
int length)
Get the lpad(field, length) function
|
static Field<String> |
Factory.lpad(Field<String> field,
int length,
char character)
Get the lpad(field, length, character) function
|
static Field<String> |
Factory.lpad(Field<String> field,
int length,
String character)
Get the lpad(field, length, character) function
|
static Field<String> |
Factory.ltrim(Field<String> field)
Get the ltrim(field) function
This renders the ltrim function in all dialects:
ltrim([field]) |
static Field<String> |
Factory.ltrim(String value)
Get the ltrim(field) function
|
static Field<Integer> |
Factory.minute(Date value)
Get the minute part of a date
This is the same as calling
Factory.extract(java.util.Date, DatePart)
with DatePart.MINUTE |
static Field<Integer> |
Factory.minute(Field<? extends Date> field)
Get the minute part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.MINUTE |
static Field<Integer> |
Factory.month(Date value)
Get the month part of a date
This is the same as calling
Factory.extract(java.util.Date, DatePart)
with DatePart.MONTH |
static Field<Integer> |
Factory.month(Field<? extends Date> field)
Get the month part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.MONTH |
Field<T> |
CustomField.mul(Field<? extends Number> value) |
Field<T> |
SequenceImpl.nextval() |
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
|
protected static Field<?>[] |
Factory.nullSafe(Field<?>... fields)
Null-safety of a field
|
protected static <T> Field<T> |
Factory.nullSafe(Field<T> field)
Null-safety of a field
|
static <T> Field<T> |
Factory.nvl(Field<T> value,
Field<T> defaultValue)
|
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 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 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> |
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> |
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> |
Factory.round(T value)
Get rounded value of a numeric field: round(field)
|
static <T extends Number> |
Factory.round(T value,
int decimals)
Get rounded value of a numeric field: round(field, decimals)
|
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 Field<Integer> |
Factory.second(Date value)
Get the second part of a date
This is the same as calling
Factory.extract(java.util.Date, DatePart)
with DatePart.SECOND |
static Field<Integer> |
Factory.second(Field<? extends Date> field)
Get the second part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.SECOND |
static <T extends Number> |
Factory.shl(Field<T> field1,
Field<T> field2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shl(Field<T> value1,
T value2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shl(T value1,
Field<T> value2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shl(T value1,
T value2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shr(Field<T> field1,
Field<T> field2)
The bitwise right shift operator.
|
static <T extends Number> |
Factory.shr(Field<T> value1,
T value2)
The bitwise right shift operator.
|
static <T extends Number> |
Factory.shr(T value1,
Field<T> value2)
The bitwise right shift operator.
|
static <T extends Number> |
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 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 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 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 <T extends Number> |
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> |
Factory.trunc(Field<T> number,
int decimals)
Truncate a number to a given number of decimals
|
static <T extends Number> |
Factory.trunc(T number)
Truncate a number to a given number of decimals
|
static <T extends Number> |
Factory.trunc(T number,
Field<Integer> decimals)
Truncate a number to a given number of decimals
|
static <T extends Number> |
Factory.trunc(T number,
int decimals)
Truncate a number to a given number of decimals
|
static Field<Integer> |
Factory.two()
A
2 literal. |
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 <T> Field<T> |
Factory.value(Object value,
Class<? extends T> type)
A synonym for
Factory.val(Object, Class) to be used in Scala and Groovy, where
val is a reserved keyword. |
static <T> Field<T> |
Factory.value(Object value,
DataType<T> type)
A synonym for
Factory.val(Object, DataType) to be used in Scala and Groovy, where
val is a reserved keyword. |
static <T> Field<T> |
Factory.value(Object value,
Field<T> field)
A synonym for
Factory.val(Object, Field) to be used in Scala and Groovy, where
val is a reserved keyword. |
static <T> Field<T> |
Factory.value(T value)
A synonym for
Factory.val(Object) to be used in Scala and Groovy, where
val is a reserved keyword. |
static Field<Integer> |
Factory.year(Date value)
Get the year part of a date
This is the same as calling
Factory.extract(java.util.Date, DatePart)
with DatePart.YEAR |
static Field<Integer> |
Factory.year(Field<? extends Date> field)
Get the year part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.YEAR |
static Field<Integer> |
Factory.zero()
A
0 literal. |
Modifier and Type | Method and Description |
---|---|
protected Map<Parameter<?>,Field<?>> |
AbstractRoutine.getInValues() |
static List<Field<?>> |
Factory.vals(Object... values)
Get a list of bind values and fields
|
Modifier and Type | Method and Description |
---|---|
static <T extends Number> |
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 Field<BigDecimal> |
Factory.acos(Field<? extends Number> field)
Get the arc cosine(field) function
This renders the acos function where available:
acos([field]) |
Field<T> |
CustomField.add(Field<?> value) |
static Field<Integer> |
Factory.ascii(Field<String> field)
Get the ascii(field) function
This renders the ascii function:
ascii([field]) |
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.atan(Field<? extends Number> field)
Get the arc tangent(field) function
This renders the atan function where available:
atan([field]) |
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,
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 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> |
Factory.bitAnd(Field<T> field1,
Field<T> field2)
The bitwise and operator.
|
static <T extends Number> |
Factory.bitAnd(Field<T> field1,
Field<T> field2)
The bitwise and operator.
|
static <T extends Number> |
Factory.bitAnd(Field<T> value1,
T value2)
The bitwise and operator.
|
static <T extends Number> |
Factory.bitAnd(T value1,
Field<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.bitLength(Field<String> field)
Get the bit_length(field) function
This translates into any dialect
|
static <T extends Number> |
Factory.bitNand(Field<T> field1,
Field<T> field2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNand(Field<T> field1,
Field<T> field2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNand(Field<T> value1,
T value2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNand(T value1,
Field<T> value2)
The bitwise not and operator.
|
static <T extends Number> |
Factory.bitNor(Field<T> field1,
Field<T> field2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNor(Field<T> field1,
Field<T> field2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNor(Field<T> value1,
T value2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNor(T value1,
Field<T> value2)
The bitwise not or operator.
|
static <T extends Number> |
Factory.bitNot(Field<T> field)
The bitwise not operator.
|
static <T extends Number> |
Factory.bitOr(Field<T> field1,
Field<T> field2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitOr(Field<T> field1,
Field<T> field2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitOr(Field<T> value1,
T value2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitOr(T value1,
Field<T> value2)
The bitwise or operator.
|
static <T extends Number> |
Factory.bitXNor(Field<T> field1,
Field<T> field2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXNor(Field<T> field1,
Field<T> field2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXNor(Field<T> value1,
T value2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXNor(T value1,
Field<T> value2)
The bitwise not xor operator.
|
static <T extends Number> |
Factory.bitXor(Field<T> field1,
Field<T> field2)
The bitwise xor operator.
|
static <T extends Number> |
Factory.bitXor(Field<T> field1,
Field<T> field2)
The bitwise xor operator.
|
static <T extends Number> |
Factory.bitXor(Field<T> value1,
T value2)
The bitwise xor operator.
|
static <T extends Number> |
Factory.bitXor(T value1,
Field<T> value2)
The bitwise xor operator.
|
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(Field<T> as)
Cast null to the type of another field.
|
static <T extends Number> |
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 Field<Integer> |
Factory.charLength(Field<String> field)
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(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 Field<String> |
Factory.concat(Field<?>... fields)
Get the concat(field[, field, ...]) function
This creates
fields[0] || fields[1] || ... |
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.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.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.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 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 Field<Date> |
Factory.dateAdd(Field<Date> date,
Field<? extends 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,
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.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(Field<? extends Date> field)
Get the day part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.DAY |
static <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)
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)
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(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(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(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 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<String> |
Factory.escape(Field<String> field,
char escape)
Convenience method for
Factory.replace(Field, String, String) to escape
data for use with like(Field, char)
Essentially, this escapes % and _ characters |
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<Integer> |
Factory.extract(Field<? extends Date> field,
DatePart datePart)
Get the extract(field, datePart) function
This translates into any dialect
|
<Z> List<P> |
DAOImpl.fetch(Field<Z> field,
Z... values) |
<Z> P |
DAOImpl.fetchOne(Field<Z> field,
Z value) |
static <T> WindowIgnoreNullsStep<T> |
Factory.firstValue(Field<T> field)
The
first_value(field) over ([analytic clause]) function. |
static <T extends Number> |
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> 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> T |
FieldTypeHelper.getFromSQLInput(Configuration configuration,
SQLInput stream,
Field<T> field) |
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(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 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(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(Field<? extends Date> field)
Get the hour part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.HOUR |
static <T> Param<T> |
Factory.inline(Object value,
Field<T> field)
Create a bind value, that is always inlined.
|
<R extends Record> |
FactoryProxy.insertInto(Table<R> into,
Field<?>... fields)
Deprecated.
|
<R extends Record> |
Factory.insertInto(Table<R> into,
Field<?>... fields)
Create a new DSL insert statement.
|
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,
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,
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(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 Field<Integer> |
Factory.length(Field<String> field)
Get the length of a
VARCHAR type. |
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 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.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<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.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)
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,
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,
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 <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)
|
<R extends Record> |
FactoryProxy.mergeInto(Table<R> table,
Field<?>... fields)
Deprecated.
|
<R extends Record> |
Factory.mergeInto(Table<R> table,
Field<?>... fields)
Create a new DSL merge statement (H2-specific syntax)
This statement is available from DSL syntax only.
|
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(Field<? extends Date> field)
Get the minute part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.MINUTE |
static Field<Integer> |
Factory.month(Field<? extends Date> field)
Get the month part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.MONTH |
Field<T> |
CustomField.mul(Field<? extends Number> value) |
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,
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
|
protected static Field<?>[] |
Factory.nullSafe(Field<?>... fields)
Null-safety of a field
|
protected static <T> Field<T> |
Factory.nullSafe(Field<T> field)
Null-safety of a field
|
protected static <T> DataType<T> |
Factory.nullSafeDataType(Field<T> field)
Get a default data type if a field is null
|
static <T> Field<T> |
Factory.nvl(Field<T> value,
Field<T> defaultValue)
|
static <T> Field<T> |
Factory.nvl(T value,
Field<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,
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,
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,
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,
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.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,
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<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,
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 <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 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.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.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.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.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.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.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.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.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 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,
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.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)
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,
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,
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> |
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> |
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 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> 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> 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> 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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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 <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 <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 <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 <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 <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 <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 <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 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)
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,
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,
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<Integer> |
Factory.second(Field<? extends Date> field)
Get the second part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.SECOND |
SelectSelectStep |
FactoryProxy.select(Field<?>... fields)
Deprecated.
|
SelectSelectStep |
Factory.select(Field<?>... fields)
Create a new DSL select statement.
|
SelectSelectStep |
FactoryProxy.selectDistinct(Field<?>... fields)
Deprecated.
|
SelectSelectStep |
Factory.selectDistinct(Field<?>... fields)
Create a new DSL select statement.
|
protected void |
AbstractRoutine.setField(Parameter<?> parameter,
Field<?> value) |
protected void |
AbstractRoutine.setNumber(Parameter<? extends Number> parameter,
Field<? extends Number> value) |
static <T extends Number> |
Factory.shl(Field<T> field1,
Field<T> field2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shl(Field<T> field1,
Field<T> field2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shl(Field<T> value1,
T value2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shl(T value1,
Field<T> value2)
The bitwise left shift operator.
|
static <T extends Number> |
Factory.shr(Field<T> field1,
Field<T> field2)
The bitwise right shift operator.
|
static <T extends Number> |
Factory.shr(Field<T> field1,
Field<T> field2)
The bitwise right shift operator.
|
static <T extends Number> |
Factory.shr(Field<T> value1,
T value2)
The bitwise right shift operator.
|
static <T extends Number> |
Factory.shr(T value1,
Field<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<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.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.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 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)
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,
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,
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(Field<?> cursor)
A synonym for
Factory.unnest(Field) |
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.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<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(Field<Timestamp> timestamp,
Field<? extends 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,
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<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 <T extends Number> |
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> |
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> |
Factory.trunc(Field<T> number,
int decimals)
Truncate a number to a given number of decimals
|
static <T extends Number> |
Factory.trunc(T number,
Field<Integer> decimals)
Truncate a number to a given number of decimals
|
static Table<?> |
Factory.unnest(Field<?> cursor)
Create a table from a field.
|
static Field<String> |
Factory.upper(Field<String> field)
Get the upper(field) function
This renders the upper function in all dialects:
upper([field]) |
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.value(Object value,
Field<T> field)
A synonym for
Factory.val(Object, Field) to be used in Scala and Groovy, where
val is a reserved keyword. |
static 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 <T> void |
FieldTypeHelper.writeToSQLOutput(SQLOutput stream,
Field<T> field,
T value) |
static Field<Integer> |
Factory.year(Field<? extends Date> field)
Get the year part of a date
This is the same as calling
Factory.extract(Field, DatePart)
with DatePart.YEAR |
Modifier and Type | Method and Description |
---|---|
<R extends Record> |
FactoryProxy.insertInto(Table<R> into,
Collection<? extends Field<?>> fields)
Deprecated.
|
<R extends Record> |
Factory.insertInto(Table<R> into,
Collection<? extends Field<?>> fields)
Create a new DSL insert statement.
|
<R extends Record> |
FactoryProxy.mergeInto(Table<R> table,
Collection<? extends Field<?>> fields)
Deprecated.
|
<R extends Record> |
Factory.mergeInto(Table<R> table,
Collection<? extends Field<?>> fields)
Create a new DSL merge statement (H2-specific syntax)
|
SelectSelectStep |
FactoryProxy.select(Collection<? extends Field<?>> fields)
Deprecated.
|
SelectSelectStep |
Factory.select(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
SelectSelectStep |
FactoryProxy.selectDistinct(Collection<? extends Field<?>> fields)
Deprecated.
|
SelectSelectStep |
Factory.selectDistinct(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
Modifier and Type | Method and Description |
---|---|
static <T> Field<T> |
CUBRIDFactory.decr(Field<T> field)
Use the CUBRID-specific
DECR() function. |
static <T> Field<T> |
CUBRIDFactory.incr(Field<T> field)
Use the CUBRID-specific
INCR() function. |
Modifier and Type | Method and Description |
---|---|
static <T> Field<T> |
CUBRIDFactory.decr(Field<T> field)
Use the CUBRID-specific
DECR() function. |
static <T> Field<T> |
CUBRIDFactory.incr(Field<T> field)
Use the CUBRID-specific
INCR() function. |
Modifier and Type | Method and Description |
---|---|
static Field<String> |
MySQLFactory.aesDecrypt(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
AES_DECRYPT() function |
static Field<String> |
MySQLFactory.aesDecrypt(String cryptString,
String keyString)
Get the MySQL-specific
AES_DECRYPT() function |
static Field<String> |
MySQLFactory.aesEncrypt(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
AES_ENCRYPT() function |
static Field<String> |
MySQLFactory.aesEncrypt(String string,
String keyString)
Get the MySQL-specific
AES_ENCRYPT() function |
static Field<String> |
MySQLFactory.compress(Field<String> string)
Get the MySQL-specific
COMPRESS() function |
static Field<String> |
MySQLFactory.compress(String string)
Get the MySQL-specific
COMPRESS() function |
static Field<String> |
MySQLFactory.decode(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
DECODE() function
Don't mix this up with the various Factory.decode() methods! |
static Field<String> |
MySQLFactory.decode(String cryptString,
String keyString)
Get the MySQL-specific
DECODE() function
Don't mix this up with the various Factory.decode() methods! |
static Field<String> |
MySQLFactory.desDecrypt(Field<String> cryptString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desDecrypt(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desDecrypt(String cryptString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desDecrypt(String cryptString,
String keyString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(Field<String> string)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(String string)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(String string,
String keyString)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.encode(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
ENCODE() function |
static Field<String> |
MySQLFactory.encode(String string,
String keyString)
Get the MySQL-specific
ENCODE() function |
static Field<String> |
MySQLFactory.md5(Field<String> string)
Get the MySQL-specific
MD5() function |
static Field<String> |
MySQLFactory.md5(String string)
Get the MySQL-specific
MD5() function |
static Field<String> |
MySQLFactory.password(Field<String> string)
Get the MySQL-specific
PASSWORD() function |
static Field<String> |
MySQLFactory.password(String string)
Get the MySQL-specific
PASSWORD() function |
static Field<String> |
MySQLFactory.sha1(Field<String> string)
Get the MySQL-specific
SHA1() function |
static Field<String> |
MySQLFactory.sha1(String string)
Get the MySQL-specific
SHA1() function |
static Field<String> |
MySQLFactory.sha2(Field<String> string,
Field<Integer> hashLength)
Get the MySQL-specific
SHA2() function |
static Field<String> |
MySQLFactory.sha2(String string,
int hashLength)
Get the MySQL-specific
SHA2() function |
static Field<String> |
MySQLFactory.uncompress(Field<String> string)
Get the MySQL-specific
UNCOMPRESS() function |
static Field<String> |
MySQLFactory.uncompress(String string)
Get the MySQL-specific
UNCOMPRESS() function |
static Field<Integer> |
MySQLFactory.uncompressedLength(Field<String> string)
Get the MySQL-specific
UNCOMPRESSED_LENGTH() function |
static Field<Integer> |
MySQLFactory.uncompressedLength(String string)
Get the MySQL-specific
UNCOMPRESSED_LENGTH() function |
Modifier and Type | Method and Description |
---|---|
static Field<String> |
MySQLFactory.aesDecrypt(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
AES_DECRYPT() function |
static Field<String> |
MySQLFactory.aesDecrypt(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
AES_DECRYPT() function |
static Field<String> |
MySQLFactory.aesEncrypt(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
AES_ENCRYPT() function |
static Field<String> |
MySQLFactory.aesEncrypt(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
AES_ENCRYPT() function |
static Field<String> |
MySQLFactory.compress(Field<String> string)
Get the MySQL-specific
COMPRESS() function |
static Field<String> |
MySQLFactory.decode(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
DECODE() function
Don't mix this up with the various Factory.decode() methods! |
static Field<String> |
MySQLFactory.decode(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
DECODE() function
Don't mix this up with the various Factory.decode() methods! |
static Field<String> |
MySQLFactory.desDecrypt(Field<String> cryptString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desDecrypt(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desDecrypt(Field<String> cryptString,
Field<String> keyString)
Get the MySQL-specific
DES_DECRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(Field<String> string)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.desEncrypt(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
DES_ENCRYPT() function |
static Field<String> |
MySQLFactory.encode(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
ENCODE() function |
static Field<String> |
MySQLFactory.encode(Field<String> string,
Field<String> keyString)
Get the MySQL-specific
ENCODE() function |
static Field<String> |
MySQLFactory.md5(Field<String> string)
Get the MySQL-specific
MD5() function |
static Field<String> |
MySQLFactory.password(Field<String> string)
Get the MySQL-specific
PASSWORD() function |
static Field<String> |
MySQLFactory.sha1(Field<String> string)
Get the MySQL-specific
SHA1() function |
static Field<String> |
MySQLFactory.sha2(Field<String> string,
Field<Integer> hashLength)
Get the MySQL-specific
SHA2() function |
static Field<String> |
MySQLFactory.sha2(Field<String> string,
Field<Integer> hashLength)
Get the MySQL-specific
SHA2() function |
static Field<String> |
MySQLFactory.uncompress(Field<String> string)
Get the MySQL-specific
UNCOMPRESS() function |
static Field<Integer> |
MySQLFactory.uncompressedLength(Field<String> string)
Get the MySQL-specific
UNCOMPRESSED_LENGTH() function |
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 |
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 |
Modifier and Type | Method and Description |
---|---|
static Field<Long> |
SQLiteFactory.rowid()
Retrieve the SQLite-specific
_rowid_ pseudo-field. |
Copyright © 2013. All Rights Reserved.