- java.lang.Object
-
- org.jooq.impl.DSL
-
- Direct Known Subclasses:
AccessDSL
,ASEDSL
,CUBRIDDSL
,DB2DSL
,DerbyDSL
,FirebirdDSL
,H2DSL
,HanaDSL
,HSQLDBDSL
,InformixDSL
,IngresDSL
,MariaDBDSL
,MySQLDSL
,OracleDSL
,PostgresDSL
,RedshiftDSL
,SQLiteDSL
,SQLServerDSL
,SybaseDSL
,VerticaDSL
public class DSL extends Object
A DSL "entry point" providing implementations to theorg.jooq
interfaces.The
DSLContext
and thisDSL
are the main entry point for client code, to access jOOQ classes and functionality. Here, you can instantiate all of those objects that cannot be accessed through other objects. For example, to create aField
representing a constant value, you can write:Field<String> field = DSL.val("Hello World")
Another example is the
EXISTS
clause, which you can apply to anySELECT
to form aCondition
:Condition condition = DSL.exists(DSL.select(...));
DSL and static imports
For increased fluency and readability of your jOOQ client code, it is recommended that you static import all methods from the
DSL
. For example:import static org.jooq.impl.DSL.*; public class Main { public static void main(String[] args) { DSL.select(val("Hello"), inline("World")); // DSL.val ^^^ ^^^^^^ DSL.inline } }
In order to use the "contextual DSL", call one of the various overloaded
using(Configuration)
methods:// Create and immediately execute a SELECT statement: DSL.using(connection, dialect) .selectOne() .fetch();
- Author:
- Lukas Eder
- See Also:
DSLContext
-
-
Constructor Summary
Constructors Modifier Constructor Description protected
DSL()
No instances.
-
Method Summary
All Methods Static Methods Concrete Methods Deprecated Methods Modifier and Type Method Description static <T extends Number>
@NotNull Field<T>abs(Field<T> field)
Get the absolute value of a numeric field: abs(field).static <T extends Number>
@NotNull Field<T>abs(T value)
Get the absolute value of a numeric field: abs(field).static @NotNull Field<BigDecimal>
acos(Number value)
Get the arc cosine(field) function.static @NotNull Field<BigDecimal>
acos(Field<? extends Number> field)
Get the arc cosine(field) function.static <T> @NotNull AggregateFunction<T>
aggregate(String name, Class<T> type, Field<?>... arguments)
aggregate()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregate(String name, DataType<T> type, Field<?>... arguments)
aggregate()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregate(Name name, Class<T> type, Field<?>... arguments)
aggregate()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregate(Name name, DataType<T> type, Field<?>... arguments)
aggregate()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregateDistinct(String name, Class<T> type, Field<?>... arguments)
aggregateDistinct()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregateDistinct(String name, DataType<T> type, Field<?>... arguments)
aggregateDistinct()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregateDistinct(Name name, Class<T> type, Field<?>... arguments)
aggregateDistinct()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull AggregateFunction<T>
aggregateDistinct(Name name, DataType<T> type, Field<?>... arguments)
aggregateDistinct()
can be used to access native or user-defined aggregate functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull QuantifiedSelect<Record1<T>>
all(Field<T[]> array)
Create anALL
quantified select to be used in quantified comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>
all(Field<T>... fields)
Create anALL
quantified select to be used in quantified comparison predicate expressions.static <R extends Record>
@NotNull QuantifiedSelect<R>all(Select<R> select)
Create anALL
quantified select to be used in quantified comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>
all(T... array)
Create anALL
quantified select to be used in quantified comparison predicate expressions.static AlterDatabaseStep
alterDatabase(String database)
TheALTER DATABASE
statement.static AlterDatabaseStep
alterDatabase(Catalog database)
TheALTER DATABASE
statement.static AlterDatabaseStep
alterDatabase(Name database)
TheALTER DATABASE
statement.static AlterDatabaseStep
alterDatabaseIfExists(String database)
TheALTER DATABASE IF EXISTS
statement.static AlterDatabaseStep
alterDatabaseIfExists(Catalog database)
TheALTER DATABASE IF EXISTS
statement.static AlterDatabaseStep
alterDatabaseIfExists(Name database)
TheALTER DATABASE IF EXISTS
statement.static <T> AlterDomainStep<T>
alterDomain(String domain)
TheALTER DOMAIN
statement.static <T> AlterDomainStep<T>
alterDomain(Domain<T> domain)
TheALTER DOMAIN
statement.static <T> AlterDomainStep<T>
alterDomain(Name domain)
TheALTER DOMAIN
statement.static <T> AlterDomainStep<T>
alterDomainIfExists(String domain)
TheALTER DOMAIN IF EXISTS
statement.static <T> AlterDomainStep<T>
alterDomainIfExists(Domain<T> domain)
TheALTER DOMAIN IF EXISTS
statement.static <T> AlterDomainStep<T>
alterDomainIfExists(Name domain)
TheALTER DOMAIN IF EXISTS
statement.static @NotNull AlterIndexOnStep
alterIndex(String index)
Create a new DSLALTER INDEX
statement.static @NotNull AlterIndexOnStep
alterIndex(Index index)
Create a new DSLALTER INDEX
statement.static @NotNull AlterIndexOnStep
alterIndex(Name index)
Create a new DSLALTER INDEX
statement.static @NotNull AlterIndexStep
alterIndexIfExists(String index)
Create a new DSLALTER INDEX
statement.static @NotNull AlterIndexStep
alterIndexIfExists(Index index)
Create a new DSLALTER INDEX
statement.static @NotNull AlterIndexStep
alterIndexIfExists(Name index)
Create a new DSLALTER INDEX
statement.static AlterSchemaStep
alterSchema(String schema)
TheALTER SCHEMA
statement.static AlterSchemaStep
alterSchema(Name schema)
TheALTER SCHEMA
statement.static AlterSchemaStep
alterSchema(Schema schema)
TheALTER SCHEMA
statement.static AlterSchemaStep
alterSchemaIfExists(String schema)
TheALTER SCHEMA IF EXISTS
statement.static AlterSchemaStep
alterSchemaIfExists(Name schema)
TheALTER SCHEMA IF EXISTS
statement.static AlterSchemaStep
alterSchemaIfExists(Schema schema)
TheALTER SCHEMA IF EXISTS
statement.static @NotNull AlterSequenceStep<BigInteger>
alterSequence(String sequence)
Create a new DSLALTER SEQUENCE
statement.static @NotNull AlterSequenceStep<BigInteger>
alterSequence(Name sequence)
Create a new DSLALTER SEQUENCE
statement.static <T extends Number>
@NotNull AlterSequenceStep<T>alterSequence(Sequence<T> sequence)
Create a new DSLALTER SEQUENCE
statement.static @NotNull AlterSequenceStep<BigInteger>
alterSequenceIfExists(String sequence)
Create a new DSLALTER SEQUENCE
statement.static @NotNull AlterSequenceStep<BigInteger>
alterSequenceIfExists(Name sequence)
Create a new DSLALTER SEQUENCE
statement.static <T extends Number>
@NotNull AlterSequenceStep<T>alterSequenceIfExists(Sequence<T> sequence)
Create a new DSLALTER SEQUENCE
statement.static @NotNull AlterTableStep
alterTable(String table)
Create a new DSLALTER TABLE
statement.static @NotNull AlterTableStep
alterTable(Name table)
Create a new DSLALTER TABLE
statement.static @NotNull AlterTableStep
alterTable(Table<?> table)
Create a new DSLALTER TABLE
statement.static @NotNull AlterTableStep
alterTableIfExists(String table)
Create a new DSLALTER TABLE
statement.static @NotNull AlterTableStep
alterTableIfExists(Name table)
Create a new DSLALTER TABLE
statement.static @NotNull AlterTableStep
alterTableIfExists(Table<?> table)
Create a new DSLALTER TABLE
statement.static @NotNull AlterTypeStep
alterType(String type)
Create a new DSLALTER TYPE
statement.static @NotNull AlterTypeStep
alterType(Name type)
Create a new DSLALTER TYPE
statement.static @NotNull AlterViewStep
alterView(String view)
Create a new DSLALTER VIEW
statement.static @NotNull AlterViewStep
alterView(Name view)
Create a new DSLALTER VIEW
statement.static @NotNull AlterViewStep
alterView(Table<?> view)
Create a new DSLALTER VIEW
statement.static @NotNull AlterViewStep
alterViewIfExists(String view)
Create a new DSLALTER VIEW
statement.static @NotNull AlterViewStep
alterViewIfExists(Name view)
Create a new DSLALTER VIEW
statement.static @NotNull AlterViewStep
alterViewIfExists(Table<?> view)
Create a new DSLALTER VIEW
statement.static @NotNull Condition
and(Collection<? extends Condition> conditions)
static @NotNull Condition
and(Condition... conditions)
static @NotNull Condition
and(Condition left, Condition right)
static <T> @NotNull QuantifiedSelect<Record1<T>>
any(Field<T[]> array)
Create anANY
quantified select to be used in quantified comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>
any(Field<T>... fields)
Create anANY
quantified select to be used in quantified comparison predicate expressions.static <R extends Record>
@NotNull QuantifiedSelect<R>any(Select<R> select)
Create anANY
quantified select to be used in quantified comparison predicate expressions.static <T> @NotNull QuantifiedSelect<Record1<T>>
any(T... array)
Create anANY
quantified select to be used in quantified comparison predicate expressions.static <T> @NotNull Field<T[]>
array(Collection<? extends Field<T>> fields)
Create an array literal.static <T> @NotNull Field<T[]>
array(Field<T>... fields)
Create an array literal.static <T> @NotNull Field<T[]>
array(T... values)
Create an array literal.static <T> @NotNull ArrayAggOrderByStep<T[]>
arrayAgg(Field<T> field)
Get thearray_agg()
aggregate function.static <T> @NotNull ArrayAggOrderByStep<T[]>
arrayAggDistinct(Field<T> field)
Get thearray_agg()
aggregate function.static <T> @NotNull Field<T>
arrayGet(Field<T[]> field, int index)
Get an array element at a given index (1 based)static <T> @NotNull Field<T>
arrayGet(Field<T[]> field, Field<Integer> index)
Get an array element at a given index (1 based)static @NotNull Field<Integer>
ascii(String field)
Get the ascii(field) function.static @NotNull Field<Integer>
ascii(Field<String> field)
Get the ascii(field) function.static @NotNull Field<BigDecimal>
asin(Number value)
Get the arc sine(field) function.static @NotNull Field<BigDecimal>
asin(Field<? extends Number> field)
Get the arc sine(field) function.static @NotNull Asterisk
asterisk()
The asterisk (*
) to be used inSELECT
clauses.static @NotNull Field<BigDecimal>
atan(Number value)
Get the arc tangent(field) function.static @NotNull Field<BigDecimal>
atan(Field<? extends Number> field)
Get the arc tangent(field) function.static @NotNull Field<BigDecimal>
atan2(Number x, Number y)
Get the atan2(field, y) function.static @NotNull Field<BigDecimal>
atan2(Number x, Field<? extends Number> y)
Get the atan2(field, y) function.static @NotNull Field<BigDecimal>
atan2(Field<? extends Number> x, Number y)
Get the atan2(field, y) function.static @NotNull Field<BigDecimal>
atan2(Field<? extends Number> x, Field<? extends Number> y)
Get the atan2(field, y) function.static @NotNull AggregateFunction<BigDecimal>
avg(Field<? extends Number> field)
Get the average over a numeric field: avg(field).static @NotNull AggregateFunction<BigDecimal>
avgDistinct(Field<? extends Number> field)
Get the average over a numeric field: avg(distinct field).static @NotNull Block
begin(Collection<? extends Statement> statements)
Wrap a collection of statements in an anonymous procedural block.static @NotNull Block
begin(Statement... statements)
Wrap a collection of statements in an anonymous procedural block.static <T extends Number>
@NotNull Field<T>bitAnd(Field<T> field1, Field<T> field2)
The bitwise and operator.static <T extends Number>
@NotNull Field<T>bitAnd(Field<T> value1, T value2)
The bitwise and operator.static <T extends Number>
@NotNull Field<T>bitAnd(T value1, Field<T> value2)
The bitwise and operator.static <T extends Number>
@NotNull Field<T>bitAnd(T value1, T value2)
The bitwise and operator.static @NotNull Field<Integer>
bitCount(Number value)
The MySQLBIT_COUNT(field)
function, counting the number of bits that are set in this number.static @NotNull Field<Integer>
bitCount(Field<? extends Number> field)
The MySQLBIT_COUNT(field)
function, counting the number of bits that are set in this number.static @NotNull Field<Integer>
bitLength(String value)
Get the bit_length(field) function.static @NotNull Field<Integer>
bitLength(Field<String> field)
Get the bit_length(field) function.static <T extends Number>
@NotNull Field<T>bitNand(Field<T> field1, Field<T> field2)
The bitwise not and operator.static <T extends Number>
@NotNull Field<T>bitNand(Field<T> value1, T value2)
The bitwise not and operator.static <T extends Number>
@NotNull Field<T>bitNand(T value1, Field<T> value2)
The bitwise not and operator.static <T extends Number>
@NotNull Field<T>bitNand(T value1, T value2)
The bitwise not and operator.static <T extends Number>
@NotNull Field<T>bitNor(Field<T> field1, Field<T> field2)
The bitwise not or operator.static <T extends Number>
@NotNull Field<T>bitNor(Field<T> value1, T value2)
The bitwise not or operator.static <T extends Number>
@NotNull Field<T>bitNor(T value1, Field<T> value2)
The bitwise not or operator.static <T extends Number>
@NotNull Field<T>bitNor(T value1, T value2)
The bitwise not or operator.static <T extends Number>
@NotNull Field<T>bitNot(Field<T> field)
The bitwise not operator.static <T extends Number>
@NotNull Field<T>bitNot(T value)
The bitwise not operator.static <T extends Number>
@NotNull Field<T>bitOr(Field<T> field1, Field<T> field2)
The bitwise or operator.static <T extends Number>
@NotNull Field<T>bitOr(Field<T> value1, T value2)
The bitwise or operator.static <T extends Number>
@NotNull Field<T>bitOr(T value1, Field<T> value2)
The bitwise or operator.static <T extends Number>
@NotNull Field<T>bitOr(T value1, T value2)
The bitwise or operator.static <T extends Number>
@NotNull Field<T>bitXNor(Field<T> field1, Field<T> field2)
The bitwise not xor operator.static <T extends Number>
@NotNull Field<T>bitXNor(Field<T> value1, T value2)
The bitwise not xor operator.static <T extends Number>
@NotNull Field<T>bitXNor(T value1, Field<T> value2)
The bitwise not xor operator.static <T extends Number>
@NotNull Field<T>bitXNor(T value1, T value2)
The bitwise not xor operator.static <T extends Number>
@NotNull Field<T>bitXor(Field<T> field1, Field<T> field2)
The bitwise xor operator.static <T extends Number>
@NotNull Field<T>bitXor(Field<T> value1, T value2)
The bitwise xor operator.static <T extends Number>
@NotNull Field<T>bitXor(T value1, Field<T> value2)
The bitwise xor operator.static <T extends Number>
@NotNull Field<T>bitXor(T value1, T value2)
The bitwise xor operator.static @NotNull AggregateFunction<Boolean>
boolAnd(Condition condition)
Get the every value over a condition: bool_and(condition).static @NotNull AggregateFunction<Boolean>
boolAnd(Field<Boolean> field)
Get the every value over a field: bool_and(field).static @NotNull AggregateFunction<Boolean>
boolOr(Condition condition)
Get the every value over a condition: bool_and(condition).static @NotNull AggregateFunction<Boolean>
boolOr(Field<Boolean> field)
Get the every value over a field: bool_and(field).static @NotNull Field<Integer>
cardinality(Field<? extends Object[]> field)
Calculate the cardinality of an array field.static @NotNull Case
case_()
Initialise aCase
statement.static <V> @NotNull CaseValueStep<V>
case_(Field<V> value)
Initialise aCase
statement.static <V> @NotNull CaseValueStep<V>
case_(V value)
Initialise aCase
statement.static <T> @NotNull Field<T>
cast(Object value, Class<T> type)
Cast a value to another type.static <T> @NotNull Field<T>
cast(Object value, DataType<T> type)
Cast a value to another type.static <T> @NotNull Field<T>
cast(Object value, Field<T> as)
Cast a value to the type of another field.static <T> @NotNull Field<T>
cast(Field<?> field, Class<T> type)
Cast a field to another type.static <T> @NotNull Field<T>
cast(Field<?> field, DataType<T> type)
Cast a field to another type.static <T> @NotNull Field<T>
cast(Field<?> field, Field<T> as)
Cast a field to the type of another field.static <T> @NotNull Field<T>
castNull(Class<T> type)
Cast null to a type.static <T> @NotNull Field<T>
castNull(DataType<T> type)
Cast null to a type.static <T> @NotNull Field<T>
castNull(Field<T> as)
Cast null to the type of another field.static @NotNull Catalog
catalog(String name)
Create a qualified catalog, given its catalog name.static @NotNull Catalog
catalog(Name name)
Create a qualified catalog, given its catalog name.static <T extends Number>
@NotNull Field<T>ceil(Field<T> field)
Get the smallest integer value not less than [field].static <T extends Number>
@NotNull Field<T>ceil(T value)
Get the smallest integer value not less than [this].static @NotNull Field<Integer>
century(Temporal value)
Get the century of a date.static @NotNull Field<Integer>
century(Date value)
Get the century of a date.static @NotNull Field<Integer>
century(Field<?> field)
Get the century of a date.static @NotNull CharacterSet
characterSet(String characterSet)
Create a character set by its unqualified name.static @NotNull CharacterSet
characterSet(Name characterSet)
Create a character set by its qualified name.static @NotNull Field<Integer>
charLength(String value)
Get the char_length(field) function.static @NotNull Field<Integer>
charLength(Field<String> field)
Get the char_length(field) function.static @NotNull ConstraintEnforcementStep
check(Condition condition)
Create an unnamed (system named)CHECK
constraint.static @NotNull Case
choose()
Initialise aCase
statement.static <T> @NotNull Field<T>
choose(int index, Field<T>... values)
The T-SQLCHOOSE()
function.static <T> @NotNull Field<T>
choose(int index, T... values)
The T-SQLCHOOSE()
function.static <T> @NotNull Field<T>
choose(Field<Integer> index, Field<T>... values)
The T-SQLCHOOSE()
function.static <T> @NotNull Field<T>
choose(Field<Integer> index, T... values)
The T-SQLCHOOSE()
function.static <V> @NotNull CaseValueStep<V>
choose(Field<V> value)
Initialise aCase
statement.static <V> @NotNull CaseValueStep<V>
choose(V value)
Initialise aCase
statement.static <T> @NotNull Field<T>
coalesce(Field<T> field, Field<?>... fields)
TheCOALESCE(field1, field2, ...
static <T> @NotNull Field<T>
coalesce(Field<T> field, T value)
TheCOALESCE(field, value)
function.static <T> @NotNull Field<T>
coalesce(T value, T... values)
TheCOALESCE(value1, value2, ...
static <T> @NotNull Field<T>
coerce(Object value, Class<T> as)
Coerce this field to another type.static <T> @NotNull Field<T>
coerce(Object value, DataType<T> as)
Coerce a field to another type.static <T> @NotNull Field<T>
coerce(Object value, Field<T> as)
Coerce this field to the type of another field.static <T> @NotNull Field<T>
coerce(Field<?> field, Class<T> as)
Coerce this field to another type.static <T> @NotNull Field<T>
coerce(Field<?> field, DataType<T> as)
Coerce a field to another type.static <T> @NotNull Field<T>
coerce(Field<?> field, Field<T> as)
Coerce this field to the type of another field.static @NotNull Collation
collation(String collation)
Create a collation by its unqualified name.static @NotNull Collation
collation(Name collation)
Create a collation by its qualified name.static <T,A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A>collect(Field<T> field, Class<A> type)
Get thecollect()
aggregate function.static <T,A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A>collect(Field<T> field, DataType<A> type)
Get thecollect()
aggregate function.static <T,A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A>collectDistinct(Field<T> field, Class<A> type)
Get thecollect()
aggregate function.static <T,A extends ArrayRecord<T>>
@NotNull ArrayAggOrderByStep<A>collectDistinct(Field<T> field, DataType<A> type)
Get thecollect()
aggregate function.static @NotNull Comment
comment(String comment)
Create a comment.static @NotNull CommentOnIsStep
commentOnColumn(Field<?> field)
Create a new DSLCOMMENT ON COLUMN
statement.static @NotNull CommentOnIsStep
commentOnColumn(Name columnName)
Create a new DSLCOMMENT ON COLUMN
statement.static @NotNull CommentOnIsStep
commentOnTable(String tableName)
Create a new DSLCOMMENT ON TABLE
statement.static @NotNull CommentOnIsStep
commentOnTable(Name tableName)
Create a new DSLCOMMENT ON TABLE
statement.static @NotNull CommentOnIsStep
commentOnTable(Table<?> table)
Create a new DSLCOMMENT ON TABLE
statement.static @NotNull CommentOnIsStep
commentOnView(String viewName)
Create a new DSLCOMMENT ON VIEW
statement.static @NotNull CommentOnIsStep
commentOnView(Name viewName)
Create a new DSLCOMMENT ON VIEW
statement.static @NotNull CommentOnIsStep
commentOnView(Table<?> view)
Create a new DSLCOMMENT ON VIEW
statement.static @NotNull Field<String>
concat(String... values)
Get the concat(value[, value, ...]) function.static @NotNull Field<String>
concat(String value, Field<String> field)
Get theconcat(value, field)
function.static @NotNull Field<String>
concat(Field<?>... fields)
Get the concat(field[, field, ...]) function.static @NotNull Field<String>
concat(Field<String> field, String value)
Get theconcat(field, value)
function.static @NotNull Condition
condition(Boolean value)
Create a condition from a boolean field.static @NotNull Condition
condition(String sql)
Create a new condition holding plain SQL.static @NotNull Condition
condition(String sql, Object... bindings)
Create a new condition holding plain SQL.static @NotNull Condition
condition(String sql, QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.static @NotNull Condition
condition(Map<Field<?>,?> map)
Create a condition from a map.static @NotNull Condition
condition(Field<Boolean> field)
Create a condition from a boolean field.static @NotNull Condition
condition(Operator operator, Collection<? extends Condition> conditions)
Return aCondition
that connects all argumentconditions
withOperator
.static @NotNull Condition
condition(Operator operator, Condition... conditions)
Return aCondition
that connects all argumentconditions
withOperator
.static @NotNull Condition
condition(Operator operator, Condition left, Condition right)
Return aCondition
that connects all argumentconditions
withOperator
.static @NotNull Condition
condition(Record record)
static @NotNull Condition
condition(SQL sql)
Create a new condition holding plain SQL.static @NotNull Field<Boolean>
connectByIsCycle()
Retrieve the Oracle-specificCONNECT_BY_ISCYCLE
pseudo-field (to be used along withCONNECT BY
clauses).static @NotNull Field<Boolean>
connectByIsLeaf()
Retrieve the Oracle-specificCONNECT_BY_ISLEAF
pseudo-field (to be used along withCONNECT BY
clauses).static <T> @NotNull Field<T>
connectByRoot(Field<T> field)
Retrieve the Oracle-specificCONNECT_BY_ROOT
pseudo-column (to be used along withCONNECT BY
clauses).static @NotNull ConstraintTypeStep
constraint()
Create an unnamed (system named)CONSTRAINT
specification.static @NotNull ConstraintTypeStep
constraint(String name)
Create aCONSTRAINT
specification.static @NotNull ConstraintTypeStep
constraint(Name name)
Create aCONSTRAINT
specification.static @NotNull ContinueWhenStep
continue_()
Create anCONTINUE
statement for use in procedural code.static @NotNull ContinueWhenStep
continue_(Label label)
Create anCONTINUE
statement for use in procedural code.static @NotNull Statement
continueWhen(Condition condition)
Create anCONTINUE
statement for use in procedural code.static @NotNull Statement
continueWhen(Field<Boolean> condition)
Create anCONTINUE
statement for use in procedural code.static <T> @NotNull Field<T>
convert(DataType<T> type, Object value, int style)
Convert a date time value to a string value using the SQL Server styleCONVERT()
function.static <T> @NotNull Field<T>
convert(DataType<T> type, Field<?> value, int style)
Convert a date time value to a string value using the SQL Server styleCONVERT()
function.static @NotNull Field<BigDecimal>
cos(Number value)
Get the cosine(field) function.static @NotNull Field<BigDecimal>
cos(Field<? extends Number> field)
Get the cosine(field) function.static @NotNull Field<BigDecimal>
cosh(Number value)
Get the hyperbolic cosine function: cosh(field).static @NotNull Field<BigDecimal>
cosh(Field<? extends Number> field)
Get the hyperbolic cosine function: cosh(field).static @NotNull Field<BigDecimal>
cot(Number value)
Get the cotangent(field) function.static @NotNull Field<BigDecimal>
cot(Field<? extends Number> field)
Get the cotangent(field) function.static @NotNull Field<BigDecimal>
coth(Number value)
Get the hyperbolic cotangent function: coth(field).static @NotNull Field<BigDecimal>
coth(Field<? extends Number> field)
Get the hyperbolic cotangent function: coth(field).static @NotNull AggregateFunction<Integer>
count()
Get the count(*) function.static @NotNull AggregateFunction<Integer>
count(Field<?> field)
Get the count(field) function.static @NotNull AggregateFunction<Integer>
count(SelectFieldOrAsterisk field)
Get the count(field) function.static @NotNull AggregateFunction<Integer>
count(Table<?> table)
Get the count(table) function.static @NotNull AggregateFunction<Integer>
countDistinct(Field<?> field)
Get the count(distinct field) function.static @NotNull AggregateFunction<Integer>
countDistinct(Field<?>... fields)
Get the count(distinct field1, field2) function.static @NotNull AggregateFunction<Integer>
countDistinct(SelectFieldOrAsterisk field)
Get the count(distinct field) function.static @NotNull AggregateFunction<Integer>
countDistinct(Table<?> table)
Get the count(distinct table) function.static CreateDatabaseFinalStep
createDatabase(String database)
TheCREATE DATABASE
statement.static CreateDatabaseFinalStep
createDatabase(Catalog database)
TheCREATE DATABASE
statement.static CreateDatabaseFinalStep
createDatabase(Name database)
TheCREATE DATABASE
statement.static CreateDatabaseFinalStep
createDatabaseIfNotExists(String database)
TheCREATE DATABASE IF NOT EXISTS
statement.static CreateDatabaseFinalStep
createDatabaseIfNotExists(Catalog database)
TheCREATE DATABASE IF NOT EXISTS
statement.static CreateDatabaseFinalStep
createDatabaseIfNotExists(Name database)
TheCREATE DATABASE IF NOT EXISTS
statement.static CreateDomainAsStep
createDomain(String domain)
TheCREATE DOMAIN
statement.static CreateDomainAsStep
createDomain(Domain<?> domain)
TheCREATE DOMAIN
statement.static CreateDomainAsStep
createDomain(Name domain)
TheCREATE DOMAIN
statement.static CreateDomainAsStep
createDomainIfNotExists(String domain)
TheCREATE DOMAIN IF NOT EXISTS
statement.static CreateDomainAsStep
createDomainIfNotExists(Domain<?> domain)
TheCREATE DOMAIN IF NOT EXISTS
statement.static CreateDomainAsStep
createDomainIfNotExists(Name domain)
TheCREATE DOMAIN IF NOT EXISTS
statement.static @NotNull CreateTableColumnStep
createGlobalTemporaryTable(String table)
Create a new DSLCREATE GLOBAL TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createGlobalTemporaryTable(Name table)
Create a new DSLCREATE GLOBAL TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createGlobalTemporaryTable(Table<?> table)
Create a new DSLCREATE GLOBAL TEMPORARY TABLE
statement.static @NotNull CreateIndexStep
createIndex()
Create a new DSLCREATE INDEX
statement.static @NotNull CreateIndexStep
createIndex(String index)
Create a new DSLCREATE INDEX
statement.static @NotNull CreateIndexStep
createIndex(Index index)
Create a new DSLCREATE INDEX
statement.static @NotNull CreateIndexStep
createIndex(Name index)
Create a new DSLCREATE INDEX
statement.static @NotNull CreateIndexStep
createIndexIfNotExists(String index)
Create a new DSLCREATE INDEX IF NOT EXISTS
statement.static @NotNull CreateIndexStep
createIndexIfNotExists(Index index)
Create a new DSLCREATE INDEX IF NOT EXISTS
statement.static @NotNull CreateIndexStep
createIndexIfNotExists(Name index)
Create a new DSLCREATE INDEX IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createOrReplaceView(String view, String... fields)
Create a new DSLCREATE OR REPLACE VIEW
statement.static @NotNull CreateViewAsStep
createOrReplaceView(String view, Function<? super Field<?>,? extends String> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createOrReplaceView(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createOrReplaceView(Name view, Name... fields)
Create a new DSLCREATE OR REPLACE VIEW
statement.static @NotNull CreateViewAsStep
createOrReplaceView(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createOrReplaceView(Table<?> view, Field<?>... fields)
Create a new DSLCREATE OR REPLACE VIEW
statement.static CreateSchemaFinalStep
createSchema(String schema)
TheCREATE SCHEMA
statement.static CreateSchemaFinalStep
createSchema(Name schema)
TheCREATE SCHEMA
statement.static CreateSchemaFinalStep
createSchema(Schema schema)
TheCREATE SCHEMA
statement.static CreateSchemaFinalStep
createSchemaIfNotExists(String schema)
TheCREATE SCHEMA IF NOT EXISTS
statement.static CreateSchemaFinalStep
createSchemaIfNotExists(Name schema)
TheCREATE SCHEMA IF NOT EXISTS
statement.static CreateSchemaFinalStep
createSchemaIfNotExists(Schema schema)
TheCREATE SCHEMA IF NOT EXISTS
statement.static CreateSequenceFlagsStep
createSequence(String sequence)
TheCREATE SEQUENCE
statement.static CreateSequenceFlagsStep
createSequence(Name sequence)
TheCREATE SEQUENCE
statement.static CreateSequenceFlagsStep
createSequence(Sequence<?> sequence)
TheCREATE SEQUENCE
statement.static CreateSequenceFlagsStep
createSequenceIfNotExists(String sequence)
TheCREATE SEQUENCE IF NOT EXISTS
statement.static CreateSequenceFlagsStep
createSequenceIfNotExists(Name sequence)
TheCREATE SEQUENCE IF NOT EXISTS
statement.static CreateSequenceFlagsStep
createSequenceIfNotExists(Sequence<?> sequence)
TheCREATE SEQUENCE IF NOT EXISTS
statement.static @NotNull CreateTableColumnStep
createTable(String table)
Create a new DSLCREATE TABLE
statement.static @NotNull CreateTableColumnStep
createTable(Name table)
Create a new DSLCREATE TABLE
statement.static @NotNull CreateTableColumnStep
createTable(Table<?> table)
Create a new DSLCREATE TABLE
statement.static @NotNull CreateTableColumnStep
createTableIfNotExists(String table)
Create a new DSLCREATE TABLE
statement.static @NotNull CreateTableColumnStep
createTableIfNotExists(Name table)
Create a new DSLCREATE TABLE
statement.static @NotNull CreateTableColumnStep
createTableIfNotExists(Table<?> table)
Create a new DSLCREATE TABLE
statement.static @NotNull CreateTableColumnStep
createTemporaryTable(String table)
Create a new DSLCREATE TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createTemporaryTable(Name table)
Create a new DSLCREATE TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createTemporaryTable(Table<?> table)
Create a new DSLCREATE TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createTemporaryTableIfNotExists(String table)
Create a new DSLCREATE TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createTemporaryTableIfNotExists(Name table)
Create a new DSLCREATE TEMPORARY TABLE
statement.static @NotNull CreateTableColumnStep
createTemporaryTableIfNotExists(Table<?> table)
Create a new DSLCREATE TEMPORARY TABLE
statement.static @NotNull CreateTypeStep
createType(String type)
Create a new DSLCREATE TYPE
statement.static @NotNull CreateTypeStep
createType(Name type)
Create a new DSLCREATE TYPE
statement.static @NotNull CreateIndexStep
createUniqueIndex()
Create a new DSLCREATE UNIQUE INDEX
statement.static @NotNull CreateIndexStep
createUniqueIndex(String index)
Create a new DSLCREATE UNIQUE INDEX
statement.static @NotNull CreateIndexStep
createUniqueIndex(Index index)
Create a new DSLCREATE UNIQUE INDEX
statement.static @NotNull CreateIndexStep
createUniqueIndex(Name index)
Create a new DSLCREATE UNIQUE INDEX
statement.static @NotNull CreateIndexStep
createUniqueIndexIfNotExists(String index)
Create a new DSLCREATE UNIQUE INDEX IF NOT EXISTS
statement.static @NotNull CreateIndexStep
createUniqueIndexIfNotExists(Index index)
Create a new DSLCREATE UNIQUE INDEX IF NOT EXISTS
statement.static @NotNull CreateIndexStep
createUniqueIndexIfNotExists(Name index)
Create a new DSLCREATE UNIQUE INDEX IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createView(String view, String... fields)
Create a new DSLCREATE VIEW
statement.static @NotNull CreateViewAsStep
createView(String view, Function<? super Field<?>,? extends String> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createView(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createView(Name view, Name... fields)
Create a new DSLCREATE VIEW
statement.static @NotNull CreateViewAsStep
createView(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createView(Table<?> view, Field<?>... fields)
Create a new DSLCREATE VIEW
statement.static @NotNull CreateViewAsStep
createViewIfNotExists(String view, String... fields)
Create a new DSLCREATE VIEW IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createViewIfNotExists(String view, Function<? super Field<?>,? extends String> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createViewIfNotExists(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createViewIfNotExists(Name view, Name... fields)
Create a new DSLCREATE VIEW IF NOT EXISTS
statement.static @NotNull CreateViewAsStep
createViewIfNotExists(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
Deprecated.- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ.static @NotNull CreateViewAsStep
createViewIfNotExists(Table<?> view, Field<?>... fields)
Create a new DSLCREATE VIEW IF NOT EXISTS
statement.static @NotNull GroupField
cube(Field<?>... fields)
Create a CUBE(field1, field2, .., fieldn) grouping field.static @NotNull GroupField
cube(FieldOrRow... fields)
Create a CUBE(field1, field2, .., fieldn) grouping field.static @NotNull WindowOverStep<BigDecimal>
cumeDist()
Thecume_dist() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
cumeDist(Collection<? extends Field<?>> fields)
Thecume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<BigDecimal>
cumeDist(Field<?>... fields)
Thecume_dist(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull Field<Date>
currentDate()
Get the current_date() function returning a SQL standardSQLDataType.DATE
type.static @NotNull Field<Instant>
currentInstant()
Get the current_timestamp() function.static @NotNull Field<LocalDate>
currentLocalDate()
Get the current_date() function returning a SQL standardSQLDataType.DATE
type.static @NotNull Field<LocalDateTime>
currentLocalDateTime()
Get the current_timestamp() function returning a SQL standardSQLDataType.TIMESTAMP
type.static @NotNull Field<LocalTime>
currentLocalTime()
Get the current_time() function returning a SQL standardSQLDataType.TIME
type.static @NotNull Field<OffsetDateTime>
currentOffsetDateTime()
Get the current_timestamp() function.static @NotNull Field<OffsetTime>
currentOffsetTime()
Get the current_time() function.static @NotNull Field<String>
currentSchema()
Get thecurrent_schema()
function.static @NotNull Field<Time>
currentTime()
Get the current_time() function returning a SQL standardSQLDataType.TIME
type.static @NotNull Field<Timestamp>
currentTimestamp()
Get the current_timestamp() function returning a SQL standardSQLDataType.TIMESTAMP
type.static @NotNull Field<Timestamp>
currentTimestamp(Field<Integer> precision)
Get the current_timestamp() function returning a SQL standardSQLDataType.TIMESTAMP
type with the specified fractional seconds precision.static @NotNull Field<String>
currentUser()
Get thecurrent_user()
function.static @NotNull Field<Date>
date(String value)
Convert a string value to aDATE
.static @NotNull Field<Date>
date(Date value)
Convert a temporal value to aDATE
.static @NotNull Field<Date>
date(Field<? extends Date> field)
Convert a temporal value to aDATE
.static @NotNull Field<Date>
dateAdd(Date date, Number interval)
Add an interval to a date.static @NotNull Field<Date>
dateAdd(Date date, Number interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<Date>
dateAdd(Date date, Field<? extends Number> interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<Date>
dateAdd(Field<Date> date, Number interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<Date>
dateAdd(Field<Date> date, Field<? extends Number> interval)
Add an interval to a date.static @NotNull Field<Date>
dateAdd(Field<Date> date, Field<? extends Number> interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<Integer>
dateDiff(Date endDate, Date startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Integer>
dateDiff(Date endDate, Field<Date> startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Integer>
dateDiff(DatePart part, Date startDate, Date endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
dateDiff(DatePart part, Date startDate, Field<Date> endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
dateDiff(DatePart part, Field<Date> startDate, Date endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
dateDiff(DatePart part, Field<Date> startDate, Field<Date> endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
dateDiff(Field<Date> endDate, Date startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Integer>
dateDiff(Field<Date> endDate, Field<Date> startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Date>
dateSub(Date date, Number interval)
Subtract an interval from a date.static @NotNull Field<Date>
dateSub(Date date, Number interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<Date>
dateSub(Date date, Field<? extends Number> interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<Date>
dateSub(Field<Date> date, Number interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<Date>
dateSub(Field<Date> date, Field<? extends Number> interval)
Subtract an interval from a date.static @NotNull Field<Date>
dateSub(Field<Date> date, Field<? extends Number> interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<Integer>
day(Temporal value)
Get the day part of a date.static @NotNull Field<Integer>
day(Date value)
Get the day part of a date.static @NotNull Field<Integer>
day(Field<?> field)
Get the day part of a date.static @NotNull Field<Integer>
dayOfWeek(Temporal value)
Get the day of week part of a date.static @NotNull Field<Integer>
dayOfWeek(Date value)
Get the day of week part of a date.static @NotNull Field<Integer>
dayOfWeek(Field<?> field)
Get the day of week part of a date.static @NotNull Field<Integer>
dayOfYear(Temporal value)
Get the day of week part of a date.static @NotNull Field<Integer>
dayOfYear(Date value)
Get the day of week part of a date.static @NotNull Field<Integer>
dayOfYear(Field<?> field)
Get the day of week part of a date.static @NotNull Field<Integer>
decade(Temporal value)
Get the decade of a date.static @NotNull Field<Integer>
decade(Date value)
Get the decade of a date.static @NotNull Field<Integer>
decade(Field<?> field)
Get the decade of a date.static <T> @NotNull Declaration<T>
declare(Variable<T> variable)
Create a local variable declaration for use in procedural code.static @NotNull Case
decode()
Initialise aCase
statement.static <Z,T>
@NotNull Field<Z>decode(Field<T> value, Field<T> search, Field<Z> result)
Gets the Oracle-styleDECODE(expression, search, result[, search , result]...
static <Z,T>
@NotNull Field<Z>decode(Field<T> value, Field<T> search, Field<Z> result, Field<?>... more)
Gets the Oracle-styleDECODE(expression, search, result[, search , result]...
static <Z,T>
@NotNull Field<Z>decode(T value, T search, Z result)
Gets the Oracle-styleDECODE(expression, search, result[, search , result]...
static <Z,T>
@NotNull Field<Z>decode(T value, T search, Z result, Object... more)
Gets the Oracle-styleDECODE(expression, search, result[, search , result]...
static @NotNull Field<Object>
default_()
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static <T> @NotNull Field<T>
default_(Class<T> type)
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static <T> @NotNull Field<T>
default_(DataType<T> type)
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static <T> @NotNull Field<T>
default_(Field<T> field)
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static @NotNull Field<Object>
defaultValue()
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static <T> @NotNull Field<T>
defaultValue(Class<T> type)
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static <T> @NotNull Field<T>
defaultValue(DataType<T> type)
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static <T> @NotNull Field<T>
defaultValue(Field<T> field)
Create aDEFAULT
keyword for use withINSERT
,UPDATE
, orMERGE
statements.static @NotNull Field<BigDecimal>
deg(Number value)
Calculate degrees from radians from this field.static @NotNull Field<BigDecimal>
deg(Field<? extends Number> field)
Calculate degrees from radians from this field.static <R extends Record>
@NotNull DeleteUsingStep<R>delete(Table<R> table)
Create a new DSL delete statement.static <R extends Record>
@NotNull DeleteUsingStep<R>deleteFrom(Table<R> table)
Create a new DSL delete statement.static @NotNull WindowOverStep<Integer>
denseRank()
Thedense_rank() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<Integer>
denseRank(Collection<? extends Field<?>> fields)
Thedense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>
denseRank(Field<?>... fields)
Thedense_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull Domain<?>
domain(String name)
Create aDOMAIN
reference.static @NotNull Domain<?>
domain(Name name)
Create aDOMAIN
reference.static DropDatabaseFinalStep
dropDatabase(String database)
TheDROP DATABASE
statement.static DropDatabaseFinalStep
dropDatabase(Catalog database)
TheDROP DATABASE
statement.static DropDatabaseFinalStep
dropDatabase(Name database)
TheDROP DATABASE
statement.static DropDatabaseFinalStep
dropDatabaseIfExists(String database)
TheDROP DATABASE IF EXISTS
statement.static DropDatabaseFinalStep
dropDatabaseIfExists(Catalog database)
TheDROP DATABASE IF EXISTS
statement.static DropDatabaseFinalStep
dropDatabaseIfExists(Name database)
TheDROP DATABASE IF EXISTS
statement.static DropDomainCascadeStep
dropDomain(String domain)
TheDROP DOMAIN
statement.static DropDomainCascadeStep
dropDomain(Domain<?> domain)
TheDROP DOMAIN
statement.static DropDomainCascadeStep
dropDomain(Name domain)
TheDROP DOMAIN
statement.static DropDomainCascadeStep
dropDomainIfExists(String domain)
TheDROP DOMAIN IF EXISTS
statement.static DropDomainCascadeStep
dropDomainIfExists(Domain<?> domain)
TheDROP DOMAIN IF EXISTS
statement.static DropDomainCascadeStep
dropDomainIfExists(Name domain)
TheDROP DOMAIN IF EXISTS
statement.static @NotNull DropIndexOnStep
dropIndex(String index)
Create a new DSLDROP INDEX
statement.static @NotNull DropIndexOnStep
dropIndex(Index index)
Create a new DSLDROP INDEX
statement.static @NotNull DropIndexOnStep
dropIndex(Name index)
Create a new DSLDROP INDEX
statement.static @NotNull DropIndexOnStep
dropIndexIfExists(String index)
Create a new DSLDROP INDEX IF EXISTS
statement.static @NotNull DropIndexOnStep
dropIndexIfExists(Index index)
Create a new DSLDROP INDEX IF EXISTS
statement.static @NotNull DropIndexOnStep
dropIndexIfExists(Name index)
Create a new DSLDROP INDEX IF EXISTS
statement.static DropSchemaStep
dropSchema(String schema)
TheDROP SCHEMA
statement.static DropSchemaStep
dropSchema(Name schema)
TheDROP SCHEMA
statement.static DropSchemaStep
dropSchema(Schema schema)
TheDROP SCHEMA
statement.static DropSchemaStep
dropSchemaIfExists(String schema)
TheDROP SCHEMA IF EXISTS
statement.static DropSchemaStep
dropSchemaIfExists(Name schema)
TheDROP SCHEMA IF EXISTS
statement.static DropSchemaStep
dropSchemaIfExists(Schema schema)
TheDROP SCHEMA IF EXISTS
statement.static DropSequenceFinalStep
dropSequence(String sequence)
TheDROP SEQUENCE
statement.static DropSequenceFinalStep
dropSequence(Name sequence)
TheDROP SEQUENCE
statement.static DropSequenceFinalStep
dropSequence(Sequence<?> sequence)
TheDROP SEQUENCE
statement.static DropSequenceFinalStep
dropSequenceIfExists(String sequence)
TheDROP SEQUENCE IF EXISTS
statement.static DropSequenceFinalStep
dropSequenceIfExists(Name sequence)
TheDROP SEQUENCE IF EXISTS
statement.static DropSequenceFinalStep
dropSequenceIfExists(Sequence<?> sequence)
TheDROP SEQUENCE IF EXISTS
statement.static @NotNull DropTableStep
dropTable(String table)
Create a new DSLDROP TABLE
statement.static @NotNull DropTableStep
dropTable(Name table)
Create a new DSLDROP TABLE
statement.static @NotNull DropTableStep
dropTable(Table<?> table)
Create a new DSLDROP TABLE
statement.static @NotNull DropTableStep
dropTableIfExists(String table)
Create a new DSLDROP TABLE IF EXISTS
statement.static @NotNull DropTableStep
dropTableIfExists(Name table)
Create a new DSLDROP TABLE IF EXISTS
statement.static @NotNull DropTableStep
dropTableIfExists(Table<?> table)
Create a new DSLDROP TABLE IF EXISTS
statement.static @NotNull DropTableStep
dropTemporaryTable(String table)
Create a new DSLDROP TEMPORARY TABLE
statement.static @NotNull DropTableStep
dropTemporaryTable(Name table)
Create a new DSLDROP TEMPORARY TABLE
statement.static @NotNull DropTableStep
dropTemporaryTable(Table<?> table)
Create a new DSLDROP TEMPORARY TABLE
statement.static @NotNull DropTableStep
dropTemporaryTableIfExists(String table)
Create a new DSLDROP TEMPORARY TABLE IF EXISTS
statement.static @NotNull DropTableStep
dropTemporaryTableIfExists(Name table)
Create a new DSLDROP TEMPORARY TABLE IF EXISTS
statement.static @NotNull DropTableStep
dropTemporaryTableIfExists(Table<?> table)
Create a new DSLDROP TEMPORARY TABLE IF EXISTS
statement.static @NotNull DropTypeStep
dropType(String type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropType(String... type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropType(Collection<?> type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropType(Name type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropType(Name... type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(String type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(String... type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(Collection<?> type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(Name type)
Create a new DSLDROP TYPE
statement.static @NotNull DropTypeStep
dropTypeIfExists(Name... type)
Create a new DSLDROP TYPE
statement.static @NotNull DropViewFinalStep
dropView(String view)
Create a new DSLDROP VIEW
statement.static @NotNull DropViewFinalStep
dropView(Name view)
Create a new DSLDROP VIEW
statement.static @NotNull DropViewFinalStep
dropView(Table<?> view)
Create a new DSLDROP VIEW
statement.static @NotNull DropViewFinalStep
dropViewIfExists(String view)
Create a new DSLDROP VIEW IF EXISTS
statement.static @NotNull DropViewFinalStep
dropViewIfExists(Name view)
Create a new DSLDROP VIEW IF EXISTS
statement.static @NotNull DropViewFinalStep
dropViewIfExists(Table<?> view)
Create a new DSLDROP VIEW IF EXISTS
statement.static @NotNull Table<Record>
dual()
TheDUAL
table to be used for syntactic completeness.static @NotNull Field<BigDecimal>
e()
TheE
literal (Euler number).static @NotNull Field<Integer>
epoch(Temporal value)
Get the epoch of a date.static @NotNull Field<Integer>
epoch(Date value)
Get the epoch of a date.static @NotNull Field<Integer>
epoch(Field<?> field)
Get the epoch of a date.static @NotNull String
escape(String value, char escape)
Convenience method forreplace(Field, String, String)
to escape data for use withField.like(Field, char)
.static @NotNull Field<String>
escape(Field<String> field, char escape)
Convenience method forreplace(Field, String, String)
to escape data for use withField.like(Field, char)
.static @NotNull AggregateFunction<Boolean>
every(Condition condition)
Get the every value over a condition: every(condition).static @NotNull AggregateFunction<Boolean>
every(Field<Boolean> field)
Get the every value over a field: every(field).static @NotNull Statement
execute(String sql)
Execute a statement dynamically from within procedural code.static @NotNull Statement
execute(Field<String> sql)
Execute a statement dynamically from within procedural code.static @NotNull Statement
execute(Query sql)
Execute a statement dynamically from within procedural code.static @NotNull Condition
exists(Select<?> query)
Create an exists condition.static @NotNull ExitWhenStep
exit()
Create anEXIT
statement for use in procedural code.static @NotNull ExitWhenStep
exit(Label label)
Create anEXIT
statement for use in procedural code.static @NotNull Statement
exitWhen(Condition condition)
Create anEXIT
statement for use in procedural code.static @NotNull Statement
exitWhen(Field<Boolean> condition)
Create anEXIT
statement for use in procedural code.static @NotNull Field<BigDecimal>
exp(Number value)
Get the exp(field) function, taking this field as the power of e.static @NotNull Field<BigDecimal>
exp(Field<? extends Number> field)
Get the exp(field) function, taking this field as the power of e.static @NotNull Field<Integer>
extract(Temporal value, DatePart datePart)
Get the extract(field, datePart) function.static @NotNull Field<Integer>
extract(Date value, DatePart datePart)
Get the extract(field, datePart) function.static @NotNull Field<Integer>
extract(Field<?> field, DatePart datePart)
Get the extract(field, datePart) function.static @NotNull False
falseCondition()
Return aCondition
that will always evaluate to false.static @NotNull Field<Object>
field(String sql)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(String sql, Class<T> type)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(String sql, Class<T> type, Object... bindings)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(String sql, Class<T> type, QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.static @NotNull Field<Object>
field(String sql, Object... bindings)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(String sql, DataType<T> type)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(String sql, DataType<T> type, Object... bindings)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(String sql, DataType<T> type, QueryPart... parts)
Create a "plain SQL" field.static @NotNull Field<Object>
field(String sql, QueryPart... parts)
A custom SQL clause that can render arbitrary SQL elements.static @NotNull Field<Boolean>
field(Condition condition)
Transform a condition into a boolean field.static @NotNull Field<Object>
field(Name name)
Create a qualified field, given its (qualified) field name.static <T> @NotNull Field<T>
field(Name name, Class<T> type)
Create a qualified field, given its (qualified) field name.static <T> @NotNull Field<T>
field(Name name, DataType<T> type)
Create a qualified field, given its (qualified) field name.static <T> @NotNull Field<T>
field(Name name, DataType<T> type, Comment comment)
Create a qualified field, given its (qualified) field name.static <T> @NotNull Field<T>
field(Select<? extends Record1<T>> select)
Transform a subquery into a correlated subquery.static <T> @NotNull Field<T>
field(SelectField<T> field)
Wrap aSelectField
in a general-purposeField
static @NotNull Field<Object>
field(SQL sql)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(SQL sql, Class<T> type)
Create a "plain SQL" field.static <T> @NotNull Field<T>
field(SQL sql, DataType<T> type)
Create a "plain SQL" field.static <T> @NotNull Field<T>
fieldByName(Class<T> type, String... qualifiedName)
Deprecated.- [#3843] - 3.6.0 - usefield(Name, Class)
insteadstatic @NotNull Field<Object>
fieldByName(String... qualifiedName)
Deprecated.- [#3843] - 3.6.0 - usefield(Name)
insteadstatic <T> @NotNull Field<T>
fieldByName(DataType<T> type, String... qualifiedName)
Deprecated.- [#3843] - 3.6.0 - usefield(Name, DataType)
insteadstatic <T> @NotNull WindowIgnoreNullsStep<T>
firstValue(Field<T> field)
Thefirst_value(field) over ([analytic clause])
function.static <T extends Number>
@NotNull Field<T>floor(Field<T> field)
Get the largest integer value not greater than [this].static <T extends Number>
@NotNull Field<T>floor(T value)
Get the largest integer value not greater than [this].static <T> @NotNull ForInStep<T>
for_(Variable<T> index)
Create aFOR
loop for use in procedural code.static @NotNull ConstraintForeignKeyReferencesStep1<?>
foreignKey(String field1)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStepN
foreignKey(String... fields)
Add aFOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep2<?,?>
foreignKey(String field1, String field2)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep3<?,?,?>
foreignKey(String field1, String field2, String field3)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep4<?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep5<?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep7<?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep8<?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep9<?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep10<?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep11<?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep12<?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep13<?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep14<?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep15<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep16<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep17<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16, String field17)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep18<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16, String field17, String field18)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep19<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16, String field17, String field18, String field19)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep20<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16, String field17, String field18, String field19, String field20)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep21<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16, String field17, String field18, String field19, String field20, String field21)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep22<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(String field1, String field2, String field3, String field4, String field5, String field6, String field7, String field8, String field9, String field10, String field11, String field12, String field13, String field14, String field15, String field16, String field17, String field18, String field19, String field20, String field21, String field22)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStepN
foreignKey(Field<?>... fields)
Add aFOREIGN KEY
clause to theCONSTRAINT
.static <T1> @NotNull ConstraintForeignKeyReferencesStep1<T1>
foreignKey(Field<T1> field1)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2>
@NotNull ConstraintForeignKeyReferencesStep2<T1,T2>foreignKey(Field<T1> field1, Field<T2> field2)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3>
@NotNull ConstraintForeignKeyReferencesStep3<T1,T2,T3>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4>
@NotNull ConstraintForeignKeyReferencesStep4<T1,T2,T3,T4>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5>
@NotNull ConstraintForeignKeyReferencesStep5<T1,T2,T3,T4,T5>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6>
@NotNull ConstraintForeignKeyReferencesStep6<T1,T2,T3,T4,T5,T6>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7>
@NotNull ConstraintForeignKeyReferencesStep7<T1,T2,T3,T4,T5,T6,T7>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8>
@NotNull ConstraintForeignKeyReferencesStep8<T1,T2,T3,T4,T5,T6,T7,T8>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9>
@NotNull ConstraintForeignKeyReferencesStep9<T1,T2,T3,T4,T5,T6,T7,T8,T9>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
@NotNull ConstraintForeignKeyReferencesStep10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
@NotNull ConstraintForeignKeyReferencesStep11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
@NotNull ConstraintForeignKeyReferencesStep12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
@NotNull ConstraintForeignKeyReferencesStep13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
@NotNull ConstraintForeignKeyReferencesStep14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
@NotNull ConstraintForeignKeyReferencesStep15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
@NotNull ConstraintForeignKeyReferencesStep16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
@NotNull ConstraintForeignKeyReferencesStep17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
@NotNull ConstraintForeignKeyReferencesStep18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
@NotNull ConstraintForeignKeyReferencesStep19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>
@NotNull ConstraintForeignKeyReferencesStep20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>
@NotNull ConstraintForeignKeyReferencesStep21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>
@NotNull ConstraintForeignKeyReferencesStep22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep1<?>
foreignKey(Name field1)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStepN
foreignKey(Name... fields)
Add aFOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep2<?,?>
foreignKey(Name field1, Name field2)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep3<?,?,?>
foreignKey(Name field1, Name field2, Name field3)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep4<?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep5<?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep7<?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep8<?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep9<?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep10<?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep11<?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep12<?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep13<?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep14<?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep15<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep16<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep17<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16, Name field17)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep18<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16, Name field17, Name field18)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep19<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16, Name field17, Name field18, Name field19)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep20<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16, Name field17, Name field18, Name field19, Name field20)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep21<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16, Name field17, Name field18, Name field19, Name field20, Name field21)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static @NotNull ConstraintForeignKeyReferencesStep22<?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?>
foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6, Name field7, Name field8, Name field9, Name field10, Name field11, Name field12, Name field13, Name field14, Name field15, Name field16, Name field17, Name field18, Name field19, Name field20, Name field21, Name field22)
Add an unnamed (system named)FOREIGN KEY
clause to theCONSTRAINT
.static <T> @NotNull Field<T>
function(String name, Class<T> type, Field<?>... arguments)
function()
can be used to access native or user-defined functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>
function(String name, DataType<T> type, Field<?>... arguments)
function()
can be used to access native or user-defined functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>
function(Name name, Class<T> type, Field<?>... arguments)
function()
can be used to access native or user-defined functions that are not yet or insufficiently supported by jOOQ.static <T> @NotNull Field<T>
function(Name name, DataType<T> type, Field<?>... arguments)
function()
can be used to access native or user-defined functions that are not yet or insufficiently supported by jOOQ.static @NotNull Table<Record1<Integer>>
generateSeries(int from, int to)
A table function generating a series of values fromfrom
toto
(inclusive).static @NotNull Table<Record1<Integer>>
generateSeries(int from, int to, int step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(int from, int to, Field<Integer> step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(int from, Field<Integer> to)
A table function generating a series of values fromfrom
toto
(inclusive).static @NotNull Table<Record1<Integer>>
generateSeries(int from, Field<Integer> to, int step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(int from, Field<Integer> to, Field<Integer> step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(Field<Integer> from, int to)
A table function generating a series of values fromfrom
toto
(inclusive).static @NotNull Table<Record1<Integer>>
generateSeries(Field<Integer> from, int to, int step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(Field<Integer> from, int to, Field<Integer> step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(Field<Integer> from, Field<Integer> to)
A table function generating a series of values fromfrom
toto
(inclusive).static @NotNull Table<Record1<Integer>>
generateSeries(Field<Integer> from, Field<Integer> to, int step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static @NotNull Table<Record1<Integer>>
generateSeries(Field<Integer> from, Field<Integer> to, Field<Integer> step)
A table function generating a series of values fromfrom
toto
(inclusive), increasing values bystep
.static <T> @NotNull DataType<T>
getDataType(Class<T> type)
Deprecated.- 3.11.0 - [#7483] - The (indirect) use of the internal static data type registry is not recommended.static @NotNull Statement
goto_(Label label)
Create anGOTO
statement for use in procedural code.static GrantOnStep
grant(Collection<? extends Privilege> privileges)
TheGRANT
statement.static GrantOnStep
grant(Privilege privileges)
TheGRANT
statement.static GrantOnStep
grant(Privilege... privileges)
TheGRANT
statement.static <T> @NotNull Field<T>
greatest(Field<T> field, Field<?>... others)
Find the greatest among all values.static <T> @NotNull Field<T>
greatest(T value, T... values)
Find the greatest among all values.static @NotNull GroupConcatOrderByStep
groupConcat(Field<?> field)
Get the aggregated concatenation for a field.static @NotNull AggregateFunction<String>
groupConcat(Field<?> field, String separator)
Deprecated.- [#7956] - 3.12.0 - UsegroupConcat(Field)
andGroupConcatSeparatorStep.separator(String)
instead.static @NotNull GroupConcatOrderByStep
groupConcatDistinct(Field<?> field)
Get the aggregated concatenation for a field.static @NotNull Field<Integer>
groupId()
Create aGROUP_ID()
aggregation function to be used along withCUBE
,ROLLUP
, andGROUPING SETS
groupings.static @NotNull Field<Integer>
grouping(Field<?> field)
Create a GROUPING(field) aggregation field to be used along withCUBE
,ROLLUP
, andGROUPING SETS
groupings.static @NotNull Field<Integer>
groupingId(Field<?>... fields)
Create a GROUPING_ID(field1, field2, .., fieldn) aggregation field to be used along withCUBE
,ROLLUP
, andGROUPING SETS
groupings.static @NotNull GroupField
groupingSets(Collection<? extends Field<?>>... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna, fieldnb)) grouping field.static @NotNull GroupField
groupingSets(Field<?>... fields)
Create a GROUPING SETS(field1, field2, .., fieldn) grouping field where each grouping set only consists of a single field.static @NotNull GroupField
groupingSets(Field<?>[]... fieldSets)
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna, fieldnb)) grouping field.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenCurrentRow()
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenFollowing(int number)
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenPreceding(int number)
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenUnboundedFollowing()
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationRowsAndStep
groupsBetweenUnboundedPreceding()
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsCurrentRow()
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsFollowing(int number)
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsPreceding(int number)
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsUnboundedFollowing()
Create aWindowSpecification
with aGROUPS
clause.static @NotNull WindowSpecificationExcludeStep
groupsUnboundedPreceding()
Create aWindowSpecification
with aGROUPS
clause.static @NotNull Field<Integer>
hour(Temporal value)
Get the hour part of a date.static @NotNull Field<Integer>
hour(Date value)
Get the hour part of a date.static @NotNull Field<Integer>
hour(Field<?> field)
Get the hour part of a date.static @NotNull IfThenStep
if_(Condition condition)
Create anIF
statement for use in procedural code.static <T> @NotNull Field<T>
if_(Condition condition, Field<T> ifTrue, Field<T> ifFalse)
Create a MySQL styleIF(condition, ifTrue, ifFalse)
function.static <T> @NotNull Field<T>
if_(Condition condition, Field<T> ifTrue, T ifFalse)
Create a MySQL styleIF(condition, ifTrue, ifFalse)
function.static <T> @NotNull Field<T>
if_(Condition condition, T ifTrue, Field<T> ifFalse)
Create a MySQL styleIF(condition, ifTrue, ifFalse)
function.static <T> @NotNull Field<T>
if_(Condition condition, T ifTrue, T ifFalse)
Create a MySQL styleIF(condition, ifTrue, ifFalse)
function.static <T> @NotNull Field<T>
ifnull(Field<T> value, Field<T> defaultValue)
TheIFNULL()
function, a synonym ofNVL()
.static <T> @NotNull Field<T>
ifnull(Field<T> value, T defaultValue)
TheIFNULL()
function, a synonym ofNVL()
.static <T> @NotNull Field<T>
ifnull(T value, Field<T> defaultValue)
TheIFNULL()
function, a synonym ofNVL()
.static <T> @NotNull Field<T>
ifnull(T value, T defaultValue)
TheIFNULL()
function, a synonym ofNVL()
.static <T> @NotNull Field<T>
iif(Condition condition, Field<T> ifTrue, Field<T> ifFalse)
Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>
iif(Condition condition, Field<T> ifTrue, T ifFalse)
Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>
iif(Condition condition, T ifTrue, Field<T> ifFalse)
Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.static <T> @NotNull Field<T>
iif(Condition condition, T ifTrue, T ifFalse)
Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.static @NotNull Index
index(Name name)
Create a qualified index reference by name.static @NotNull Param<Boolean>
inline(boolean value)
Create a bind value that is always inlined.static @NotNull Param<Byte>
inline(byte value)
Create a bind value that is always inlined.static @NotNull Param<byte[]>
inline(byte[] value)
Create a bind value that is always inlined.static @NotNull Param<String>
inline(char character)
Create a bind value, that is always inlined.static @NotNull Param<Double>
inline(double value)
Create a bind value that is always inlined.static @NotNull Param<Float>
inline(float value)
Create a bind value that is always inlined.static @NotNull Param<Integer>
inline(int value)
Create a bind value that is always inlined.static @NotNull Param<Long>
inline(long value)
Create a bind value that is always inlined.static @NotNull Param<Short>
inline(short value)
Create a bind value that is always inlined.static @NotNull Param<Boolean>
inline(Boolean value)
Create a bind value that is always inlined.static @NotNull Param<Byte>
inline(Byte value)
Create a bind value that is always inlined.static @NotNull Param<String>
inline(Character character)
Create a bind value, that is always inlined.static @NotNull Param<String>
inline(CharSequence character)
Create a bind value, that is always inlined.static @NotNull Param<Double>
inline(Double value)
Create a bind value that is always inlined.static @NotNull Param<Float>
inline(Float value)
Create a bind value that is always inlined.static @NotNull Param<Integer>
inline(Integer value)
Create a bind value that is always inlined.static @NotNull Param<Long>
inline(Long value)
Create a bind value that is always inlined.static <T> @NotNull Param<T>
inline(Object value, Class<T> type)
Create a bind value, that is always inlined.static <T> @NotNull Param<T>
inline(Object value, DataType<T> type)
Create a bind value, that is always inlined.static <T> @NotNull Param<T>
inline(Object value, Field<T> field)
Create a bind value, that is always inlined.static @NotNull Param<Short>
inline(Short value)
Create a bind value that is always inlined.static @NotNull Param<String>
inline(String value)
Create a bind value that is always inlined.static @NotNull Param<BigDecimal>
inline(BigDecimal value)
Create a bind value that is always inlined.static @NotNull Param<BigInteger>
inline(BigInteger value)
Create a bind value that is always inlined.static @NotNull Param<Date>
inline(Date value)
Create a bind value that is always inlined.static @NotNull Param<Time>
inline(Time value)
Create a bind value that is always inlined.static @NotNull Param<Timestamp>
inline(Timestamp value)
Create a bind value that is always inlined.static @NotNull Param<Instant>
inline(Instant value)
Create a bind value that is always inlined.static @NotNull Param<LocalDate>
inline(LocalDate value)
Create a bind value that is always inlined.static @NotNull Param<LocalDateTime>
inline(LocalDateTime value)
Create a bind value that is always inlined.static @NotNull Param<LocalTime>
inline(LocalTime value)
Create a bind value that is always inlined.static @NotNull Param<OffsetDateTime>
inline(OffsetDateTime value)
Create a bind value that is always inlined.static @NotNull Param<OffsetTime>
inline(OffsetTime value)
Create a bind value that is always inlined.static @NotNull Param<UUID>
inline(UUID value)
Create a bind value that is always inlined.static @NotNull Param<JSON>
inline(JSON value)
Create a bind value that is always inlined.static @NotNull Param<JSONB>
inline(JSONB value)
Create a bind value that is always inlined.static @NotNull Param<UByte>
inline(UByte value)
Create a bind value that is always inlined.static @NotNull Param<UInteger>
inline(UInteger value)
Create a bind value that is always inlined.static @NotNull Param<ULong>
inline(ULong value)
Create a bind value that is always inlined.static @NotNull Param<UShort>
inline(UShort value)
Create a bind value that is always inlined.static @NotNull Param<XML>
inline(XML value)
Create a bind value that is always inlined.static <T> @NotNull Param<T>
inline(T value)
Create a bind value, that is always inlined.static @NotNull Field<String>
insert(Field<String> in, Number startIndex, Number length, String placing)
Get the insert(in, startIndex, length, placing) function.static @NotNull Field<String>
insert(Field<String> in, Field<? extends Number> startIndex, Field<? extends Number> length, Field<String> placing)
Get the insert(in, startIndex, length, placing) function.static <R extends Record>
@NotNull InsertSetStep<R>insertInto(Table<R> into)
Create a new DSL insert statement.static <R extends Record>
@NotNull InsertValuesStepN<R>insertInto(Table<R> into, Collection<? extends Field<?>> fields)
Create a new DSL insert statement.static <R extends Record>
@NotNull InsertValuesStepN<R>insertInto(Table<R> into, Field<?>... fields)
Create a new DSL insert statement.static <R extends Record,T1>
@NotNull InsertValuesStep1<R,T1>insertInto(Table<R> into, Field<T1> field1)
Create a new DSL insert statement.static <R extends Record,T1,T2>
@NotNull InsertValuesStep2<R,T1,T2>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3>
@NotNull InsertValuesStep3<R,T1,T2,T3>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4>
@NotNull InsertValuesStep4<R,T1,T2,T3,T4>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5>
@NotNull InsertValuesStep5<R,T1,T2,T3,T4,T5>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6>
@NotNull InsertValuesStep6<R,T1,T2,T3,T4,T5,T6>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7>
@NotNull InsertValuesStep7<R,T1,T2,T3,T4,T5,T6,T7>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8>
@NotNull InsertValuesStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9>
@NotNull InsertValuesStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
@NotNull InsertValuesStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
@NotNull InsertValuesStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
@NotNull InsertValuesStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
@NotNull InsertValuesStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
@NotNull InsertValuesStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
@NotNull InsertValuesStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
@NotNull InsertValuesStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
@NotNull InsertValuesStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
@NotNull InsertValuesStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
@NotNull InsertValuesStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>
@NotNull InsertValuesStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>
@NotNull InsertValuesStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
Create a new DSL insert statement.static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>
@NotNull InsertValuesStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
Create a new DSL insert statement.static @NotNull Field<Instant>
instant(String value)
Convert a string value to aTIMESTAMP WITH TIME ZONE
.static @NotNull Field<Instant>
instant(Instant value)
Convert a temporal value to aTIMESTAMP WITH TIME ZONE
.static @NotNull Field<Instant>
instant(Field<Instant> field)
Convert a temporal value to aTIMESTAMP WITH TIME ZONE
.static <T> @NotNull Field<T>
isnull(Field<T> value, Field<T> defaultValue)
Gets the SQL Server-style ISNULL(value, defaultValue) function.static <T> @NotNull Field<T>
isnull(Field<T> value, T defaultValue)
Gets the SQL Server-style ISNULL(value, defaultValue) function.static <T> @NotNull Field<T>
isnull(T value, Field<T> defaultValue)
Gets the SQL Server-style ISNULL(value, defaultValue) function.static <T> @NotNull Field<T>
isnull(T value, T defaultValue)
Gets the SQL Server-style ISNULL(value, defaultValue) function.static @NotNull Field<Integer>
isoDayOfWeek(Temporal value)
Get the ISO day of week part of a date.static @NotNull Field<Integer>
isoDayOfWeek(Date value)
Get the ISO day of week part of a date.static @NotNull Field<Integer>
isoDayOfWeek(Field<?> field)
Get the ISO day of week part of a date.static @NotNull JSONArrayNullStep<JSON>
jsonArray(Collection<? extends Field<?>> fields)
The JSON array constructor.static @NotNull JSONArrayNullStep<JSON>
jsonArray(Field<?>... fields)
The JSON array constructor.static @NotNull JSONArrayAggOrderByStep<JSON>
jsonArrayAgg(Field<?> value)
The JSON array aggregate function.static @NotNull JSONArrayNullStep<JSONB>
jsonbArray(Collection<? extends Field<?>> fields)
The JSONB array constructor.static @NotNull JSONArrayNullStep<JSONB>
jsonbArray(Field<?>... fields)
The JSONB array constructor.static @NotNull JSONArrayAggOrderByStep<JSONB>
jsonbArrayAgg(Field<?> value)
The JSON array aggregate function.static @NotNull JSONExistsOnStep
jsonbExists(Field<JSONB> field, String path)
The JSONB exists predicate.static @NotNull JSONExistsOnStep
jsonbExists(Field<JSONB> field, Field<String> path)
The JSONB exists predicate.static @NotNull JSONObjectNullStep<JSONB>
jsonbObject(Collection<? extends JSONEntry<?>> entries)
The JSONB object constructor.static @NotNull JSONObjectNullStep<JSONB>
jsonbObject(Field<?>... entries)
The JSONB object constructor.static @NotNull JSONObjectNullStep<JSONB>
jsonbObject(JSONEntry<?>... entries)
The JSONB object constructor.static @NotNull JSONObjectAggNullStep<JSONB>
jsonbObjectAgg(String key, Field<?> value)
The JSONB object aggregate function.static @NotNull JSONObjectAggNullStep<JSONB>
jsonbObjectAgg(Field<?> field)
The JSONB object aggregate function.static @NotNull JSONObjectAggNullStep<JSONB>
jsonbObjectAgg(Field<String> key, Field<?> value)
The JSONB object aggregate function.static @NotNull JSONObjectAggNullStep<JSONB>
jsonbObjectAgg(JSONEntry<?> entry)
The JSONB object aggregate function.static @NotNull JSONTableColumnsFirstStep
jsonbTable(Field<JSONB> json, Field<String> path)
The JSON table function.static @NotNull JSONTableColumnsFirstStep
jsonbTable(JSONB json, String path)
The JSON table function.static @NotNull JSONValueOnStep<JSONB>
jsonbValue(Field<JSONB> json, String path)
The JSON value extractor function.static @NotNull JSONValueOnStep<JSONB>
jsonbValue(Field<JSONB> json, Field<String> path)
The JSON value extractor function.static <T> @NotNull JSONEntry<T>
jsonEntry(String key, Field<T> value)
A constructor for JSON entries to be used withjsonObject(JSONEntry...)
.static <T> @NotNull JSONEntry<T>
jsonEntry(Field<String> key, Field<T> value)
A constructor for JSON entries to be used withjsonObject(JSONEntry...)
.static <T> @NotNull JSONEntry<T>
jsonEntry(Field<String> key, T value)
A constructor for JSON entries to be used withjsonObject(JSONEntry...)
.static <T> @NotNull JSONEntry<T>
jsonEntry(Field<T> value)
A constructor for JSON entries to be used withjsonObject(JSONEntry...)
.static @NotNull JSONExistsOnStep
jsonExists(Field<JSON> field, String path)
The JSON exists predicate.static @NotNull JSONExistsOnStep
jsonExists(Field<JSON> field, Field<String> path)
The JSON exists predicate.static @NotNull JSONObjectNullStep<JSON>
jsonObject()
The JSON object constructor.static @NotNull JSONObjectNullStep<JSON>
jsonObject(String key, Field<?> value)
The JSON object constructor.static @NotNull JSONObjectNullStep<JSON>
jsonObject(Collection<? extends JSONEntry<?>> entries)
The JSON object constructor.static @NotNull JSONObjectNullStep<JSON>
jsonObject(Field<?>... entries)
The JSON object constructor.static @NotNull JSONObjectNullStep<JSON>
jsonObject(Field<String> key, Field<?> value)
The JSON object constructor.static @NotNull JSONObjectNullStep<JSON>
jsonObject(JSONEntry<?>... entries)
The JSON object constructor.static @NotNull JSONObjectAggNullStep<JSON>
jsonObjectAgg(String key, Field<?> value)
The JSON object aggregate function.static @NotNull JSONObjectAggNullStep<JSON>
jsonObjectAgg(Field<?> value)
The JSON object aggregate function.static @NotNull JSONObjectAggNullStep<JSON>
jsonObjectAgg(Field<String> key, Field<?> value)
The JSON object aggregate function.static @NotNull JSONObjectAggNullStep<JSON>
jsonObjectAgg(JSONEntry<?> entry)
The JSON object aggregate function.static @NotNull JSONTableColumnsFirstStep
jsonTable(Field<JSON> json, Field<String> path)
The JSON table function.static @NotNull JSONTableColumnsFirstStep
jsonTable(JSON json, String path)
The JSON table function.static @NotNull JSONValueOnStep<JSON>
jsonValue(Field<JSON> json, String path)
The JSON value extractor function.static @NotNull JSONValueOnStep<JSON>
jsonValue(Field<JSON> json, Field<String> path)
The JSON value extractor function.static @NotNull JSONEntryValueStep
key(String key)
A constructor for JSON entries to be used withjsonObject(JSONEntry...)
.static @NotNull JSONEntryValueStep
key(Field<String> key)
A constructor for JSON entries to be used withjsonObject(JSONEntry...)
.static @NotNull Keyword
keyword(String keyword)
Create a SQL keyword.static @NotNull Label
label(String label)
Create a label reference for use in procedural code.static @NotNull Label
label(Name label)
Create a label reference for use in procedural code.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(Field<T> field)
Thelag(field) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(Field<T> field, int offset)
Thelag(field, offset) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(Field<T> field, int offset, Field<T> defaultValue)
Thelag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lag(Field<T> field, int offset, T defaultValue)
Thelag(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lastValue(Field<T> field)
Thelast_value(field) over ([analytic clause])
function.static <R extends Record>
@NotNull Table<R>lateral(TableLike<R> table)
Create aLATERAL
joined table.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(Field<T> field)
Thelead(field) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(Field<T> field, int offset)
Thelead(field, offset) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(Field<T> field, int offset, Field<T> defaultValue)
Thelead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull WindowIgnoreNullsStep<T>
lead(Field<T> field, int offset, T defaultValue)
Thelead(field, offset, defaultValue) over ([analytic clause])
function.static <T> @NotNull Field<T>
least(Field<T> field, Field<?>... others)
Find the least among all values.static <T> @NotNull Field<T>
least(T value, T... values)
Find the least among all values.static @NotNull Field<String>
left(String field, int length)
Get the left outermost characters from a string.static @NotNull Field<String>
left(String field, Field<? extends Number> length)
Get the left outermost characters from a string.static @NotNull Field<String>
left(Field<String> field, int length)
Get the left outermost characters from a string.static @NotNull Field<String>
left(Field<String> field, Field<? extends Number> length)
Get the left outermost characters from a string.static @NotNull Field<Integer>
length(String value)
Get the length of aVARCHAR
type.static @NotNull Field<Integer>
length(Field<String> field)
Get the length of aVARCHAR
type.static @NotNull Field<Integer>
level()
Retrieve the Oracle-specificLEVEL
pseudo-field (to be used along withCONNECT BY
clauses).static @NotNull Link
link(String name)
Create a database link reference.static @NotNull Link
link(String name, Schema schema)
Create a database link reference.static @NotNull Link
link(Name name)
Create a database link reference.static @NotNull QueryPart
list(Collection<? extends QueryPart> parts)
Compose a list ofQueryParts
into a newQueryPart
, with individual parts being comma-separated.static @NotNull QueryPart
list(QueryPart... parts)
Compose a list ofQueryParts
into a newQueryPart
, with individual parts being comma-separated.static @NotNull OrderedAggregateFunction<String>
listAgg(Field<?> field)
Get the aggregated concatenation for a field.static @NotNull OrderedAggregateFunction<String>
listAgg(Field<?> field, String separator)
Get the aggregated concatenation for a field.static @NotNull Field<BigDecimal>
ln(Number value)
Get the ln(field) function, taking the natural logarithm of this field.static @NotNull Field<BigDecimal>
ln(Field<? extends Number> field)
Get the ln(field) function, taking the natural logarithm of this field.static @NotNull Field<LocalDate>
localDate(String value)
Convert a string value to aDATE
.static @NotNull Field<LocalDate>
localDate(LocalDate value)
Convert a temporal value to aDATE
.static @NotNull Field<LocalDate>
localDate(Field<LocalDate> field)
Convert a temporal value to aDATE
.static @NotNull Field<LocalDate>
localDateAdd(LocalDate date, Number interval)
Add an interval to a date.static @NotNull Field<LocalDate>
localDateAdd(LocalDate date, Number interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<LocalDate>
localDateAdd(LocalDate date, Field<? extends Number> interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<LocalDate>
localDateAdd(Field<LocalDate> date, Number interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<LocalDate>
localDateAdd(Field<LocalDate> date, Field<? extends Number> interval)
Add an interval to a date.static @NotNull Field<LocalDate>
localDateAdd(Field<LocalDate> date, Field<? extends Number> interval, DatePart datePart)
Add an interval to a date, given a date part.static @NotNull Field<Integer>
localDateDiff(LocalDate endDate, LocalDate startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Integer>
localDateDiff(LocalDate endDate, Field<LocalDate> startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Integer>
localDateDiff(DatePart part, LocalDate startDate, LocalDate endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
localDateDiff(DatePart part, LocalDate startDate, Field<LocalDate> endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
localDateDiff(DatePart part, Field<LocalDate> startDate, LocalDate endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
localDateDiff(DatePart part, Field<LocalDate> startDate, Field<LocalDate> endDate)
Get the date difference betweenendDate - startDate
in terms ofpart
.static @NotNull Field<Integer>
localDateDiff(Field<LocalDate> endDate, LocalDate startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<Integer>
localDateDiff(Field<LocalDate> endDate, Field<LocalDate> startDate)
Get the date difference betweenendDate - startDate
in number of days.static @NotNull Field<LocalDate>
localDateSub(LocalDate date, Number interval)
Subtract an interval from a date.static @NotNull Field<LocalDate>
localDateSub(LocalDate date, Number interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<LocalDate>
localDateSub(LocalDate date, Field<? extends Number> interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<LocalDate>
localDateSub(Field<LocalDate> date, Number interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<LocalDate>
localDateSub(Field<LocalDate> date, Field<? extends Number> interval)
Subtract an interval from a date.static @NotNull Field<LocalDate>
localDateSub(Field<LocalDate> date, Field<? extends Number> interval, DatePart datePart)
Subtract an interval from a date, given a date part.static @NotNull Field<LocalDateTime>
localDateTime(String value)
Convert a string value to aTIMESTAMP
.static @NotNull Field<LocalDateTime>
localDateTime(LocalDateTime value)
Convert a temporal value to aTIMESTAMP
.static @NotNull Field<LocalDateTime>
localDateTime(Field<LocalDateTime> field)
Convert a temporal value to aTIMESTAMP
.static @NotNull Field<LocalDateTime>
localDateTimeAdd(LocalDateTime timestamp, Number interval)
Add an interval to a timestamp.static @NotNull Field<LocalDateTime>
localDateTimeAdd(LocalDateTime date, Number interval, DatePart datePart)
Add an interval to a timestamp, given a date part.static @NotNull Field<LocalDateTime>
localDateTimeAdd(LocalDateTime date, Field<? extends Number> interval, DatePart datePart)
Add an interval to a timestamp, given a date part.static @NotNull Field<LocalDateTime>
localDateTimeAdd(Field<LocalDateTime> date, Number interval, DatePart datePart)
Add an interval to a timestamp, given a date part.static @NotNull Field<LocalDateTime>
localDateTimeAdd(Field<LocalDateTime> timestamp, Field<? extends Number> interval)
Add an interval to a timestamp.static @NotNull Field<LocalDateTime>
localDateTimeAdd(Field<LocalDateTime> date, Field<? extends Number> interval, DatePart datePart)
Add an interval to a timestamp, given a date part.static @NotNull Field<DayToSecond>
localDateTimeDiff(LocalDateTime timestamp1, LocalDateTime timestamp2)
Get the timestamp difference as aINTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>
localDateTimeDiff(LocalDateTime timestamp1, Field<LocalDateTime> timestamp2)
Get the timestamp difference as aINTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>
localDateTimeDiff(Field<LocalDateTime> timestamp1, LocalDateTime timestamp2)
Get the timestamp difference as aINTERVAL DAY TO SECOND
type.static @NotNull Field<DayToSecond>
localDateTimeDiff(Field<LocalDateTime> timestamp1, Field<LocalDateTime> timestamp2)
Get the timestamp difference as aINTERVAL DAY TO SECOND
type.static @NotNull Field<LocalDateTime>
localDateTimeSub(LocalDateTime timestamp, Number interval)
Subtract an interval from a timestamp.static @NotNull Field<LocalDateTime>
localDateTimeSub(LocalDateTime date, Number interval, DatePart datePart)
Subtract an interval from a timestamp, given a date part.static @NotNull Field<LocalDateTime>
localDateTimeSub(LocalDateTime date, Field<? extends Number> interval, DatePart datePart)
Subtract an interval from a timestamp, given a date part.static @NotNull Field<LocalDateTime>
localDateTimeSub(Field<LocalDateTime> date, Number interval, DatePart datePart)
Subtract an interval from a timestamp, given a date part.static @NotNull Field<LocalDateTime>
localDateTimeSub(Field<LocalDateTime> timestamp, Field<? extends Number> interval)
Subtract an interval from a timestamp.static @NotNull Field<LocalDateTime>
localDateTimeSub(Field<LocalDateTime> date, Field<? extends Number> interval, DatePart datePart)
Subtract an interval from a timestamp, given a date part.static @NotNull Field<LocalTime>
localTime(String value)
Convert a string value to aTIME
.static @NotNull Field<LocalTime>
localTime(LocalTime value)
Convert a temporal value to aTIME
.static @NotNull Field<LocalTime>
localTime(Field<LocalTime> field)
Convert a temporal value to aTIME
.static @NotNull Field<BigDecimal>
log(Number value, int base)
Get the log(field, base) function.static @NotNull Field<BigDecimal>
log(Field<? extends Number> field, int base)
Get the log(field, base) function.static @NotNull Field<BigDecimal>
log(Field<? extends Number> field, Field<? extends Number> base)
Get the log(field, base) function.static @NotNull Statement
loop(Collection<? extends Statement> statements)
Create aLOOP
for use in procedural code.static @NotNull Statement
loop(Statement... statements)
Create aLOOP
for use in procedural code.static @NotNull Field<String>
lower(String value)
Get the lower(field) function.static @NotNull Field<String>
lower(Field<String> field)
Get the lower(field) function.static @NotNull Field<String>
lpad(Field<String> field, int length)
Get the lpad(field, length) function.static @NotNull Field<String>
lpad(Field<String> field, int length, char character)
Get the lpad(field, length, character) function.static @NotNull Field<String>
lpad(Field<String> field, int length, String character)
Get the lpad(field, length, character) function.static @NotNull Field<String>
lpad(Field<String> field, Field<? extends Number> length)
Get the lpad(field, length) function.static @NotNull Field<String>
lpad(Field<String> field, Field<? extends Number> length, Field<String> character)
Get the lpad(field, length, character) function.static @NotNull Field<String>
ltrim(String value)
Get the ltrim(field) function.static @NotNull Field<String>
ltrim(String value, String characters)
Get theltrim(field, characters)
ortrim(leading characters from field)
function.static @NotNull Field<String>
ltrim(Field<String> field)
Get the ltrim(field) function.static @NotNull Field<String>
ltrim(Field<String> field, Field<String> characters)
Get theltrim(field, characters)
ortrim(leading characters from field)
function.static <T> @NotNull AggregateFunction<T>
max(Field<T> field)
Get the max value over a field: max(field).static <T> @NotNull AggregateFunction<T>
maxDistinct(Field<T> field)
Get the max value over a field: max(distinct field).static @NotNull Field<String>
md5(String string)
Get the MySQL-specificMD5()
function.static @NotNull Field<String>
md5(Field<String> string)
Get the MySQL-specificMD5()
function.static @NotNull AggregateFunction<BigDecimal>
median(Field<? extends Number> field)
Get the median over a numeric field: median(field).static <R extends Record>
@NotNull MergeUsingStep<R>mergeInto(Table<R> table)
Create a new DSL SQL standard MERGE statement.static <R extends Record>
@NotNull MergeKeyStepN<R>mergeInto(Table<R> table, Collection<? extends Field<?>> fields)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record>
@NotNull MergeKeyStepN<R>mergeInto(Table<R> table, Field<?>... fields)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1>
@NotNull MergeKeyStep1<R,T1>mergeInto(Table<R> table, Field<T1> field1)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2>
@NotNull MergeKeyStep2<R,T1,T2>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3>
@NotNull MergeKeyStep3<R,T1,T2,T3>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4>
@NotNull MergeKeyStep4<R,T1,T2,T3,T4>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5>
@NotNull MergeKeyStep5<R,T1,T2,T3,T4,T5>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6>
@NotNull MergeKeyStep6<R,T1,T2,T3,T4,T5,T6>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7>
@NotNull MergeKeyStep7<R,T1,T2,T3,T4,T5,T6,T7>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8>
@NotNull MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9>
@NotNull MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
@NotNull MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
@NotNull MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
@NotNull MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
@NotNull MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
@NotNull MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
@NotNull MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
@NotNull MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
@NotNull MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
@NotNull MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
@NotNull MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>
@NotNull MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>
@NotNull MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>
@NotNull MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
Deprecated.- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, viamergeInto(Table)
static @NotNull Field<Integer>
microsecond(Temporal value)
Get the microsecond part of a date.static @NotNull Field<Integer>
microsecond(Date value)
Get the microsecond part of a date.static @NotNull Field<Integer>
microsecond(Field<?> field)
Get the microsecond part of a date.static @NotNull Field<String>
mid(Field<String> field, int startingPosition, int length)
Get the mid(field, startingPosition, length) function.static @NotNull Field<String>
mid(Field<String> field, Field<? extends Number> startingPosition, Field<? extends Number> length)
Get the mid(field, startingPosition, length) function.static @NotNull Field<Integer>
millennium(Temporal value)
Get the millennium of a date.static @NotNull Field<Integer>
millennium(Date value)
Get the millennium of a date.static @NotNull Field<Integer>
millennium(Field<?> field)
Get the millennium of a date.static @NotNull Field<Integer>
millisecond(Temporal value)
Get the millisecond part of a date.static @NotNull Field<Integer>
millisecond(Date value)
Get the millisecond part of a date.static @NotNull Field<Integer>
millisecond(Field<?> field)
Get the millisecond part of a date.static <T> @NotNull AggregateFunction<T>
min(Field<T> field)
Get the min value over a field: min(field).static <T> @NotNull AggregateFunction<T>
minDistinct(Field<T> field)
Get the min value over a field: min(distinct field).static <T extends Number>
@NotNull Field<T>minus(Field<T> field)
Negate a field to get its negative value.static @NotNull Field<Integer>
minute(Temporal value)
Get the minute part of a date.static @NotNull Field<Integer>
minute(Date value)
Get the minute part of a date.static @NotNull Field<Integer>
minute(Field<?> field)
Get the minute part of a date.static @NotNull OrderedAggregateFunctionOfDeferredType
mode()
Themode() within group (oder by [order clause])
ordered aggregate function.static <T> @NotNull AggregateFunction<T>
mode(Field<T> field)
Themode(field)
aggregate function.static @NotNull Field<Integer>
month(Temporal value)
Get the month part of a date.static @NotNull Field<Integer>
month(Date value)
Get the month part of a date.static @NotNull Field<Integer>
month(Field<?> field)
Get the month part of a date.static @NotNull Name
name(String unqualifiedName)
Create a new SQL identifier using an unqualified name.static @NotNull Name
name(String... qualifiedName)
Create a new SQL identifier using a qualified name.static @NotNull Name
name(Collection<String> qualifiedName)
Create a new SQL identifier using a qualified name.static @NotNull Name
name(Name... nameParts)
Create a new SQL identifier using a qualified name.static <T extends Number>
@NotNull Field<T>neg(Field<T> field)
Negate a field to get its negative value.static @NotNull Condition
noCondition()
Return aCondition
that behaves like no condition being present.static @NotNull Field<Boolean>
not(Boolean value)
Deprecated.- 3.8.0 - [#4763] - Usenot(Condition)
instead.static @NotNull Condition
not(Condition condition)
Invert a condition.static @NotNull Field<Boolean>
not(Field<Boolean> field)
Invert a boolean value.static @NotNull Condition
notExists(Select<?> query)
Create a not exists condition.static @NotNull Condition
notUnique(Select<?> query)
Create a not unique condition.static @NotNull Field<Timestamp>
now()
Synonym forcurrentTimestamp()
.static @NotNull Field<Timestamp>
now(Field<Integer> precision)
Synonym forcurrentTimestamp(Field)
.static <T> @NotNull WindowFromFirstLastStep<T>
nthValue(Field<T> field, int nth)
Thenth_value(field) over ([analytic clause])
function.static <T> @NotNull WindowFromFirstLastStep<T>
nthValue(Field<T> field, Field<Integer> nth)
Thenth_value(field) over ([analytic clause])
function.static @NotNull WindowOverStep<Integer>
ntile(int number)
Thentile([number]) over ([analytic clause])
function.static <T> @NotNull Field<T>
nullif(Field<T> value, Field<T> other)
Gets the Oracle-style NULLIF(value, other) function.static <T> @NotNull Field<T>
nullif(Field<T> value, T other)
Gets the Oracle-style NULLIF(value, other) function.static <T> @NotNull Field<T>
nullif(T value, Field<T> other)
Gets the Oracle-style NULLIF(value, other) function.static <T> @NotNull Field<T>
nullif(T value, T other)
Gets the Oracle-style NULLIF(value, other) function.protected static Field<?>[]
nullSafe(Field<?>... fields)
Null-safety of a field.protected static <T> Field<T>
nullSafe(Field<T> field)
Null-safety of a field.protected static <T> Field<T>
nullSafe(Field<T> field, DataType<?> type)
Null-safety of a field.protected static <T> DataType<T>
nullSafeDataType(Field<T> field)
Get a default data type if a field is null.protected static List<Field<?>>
nullSafeList(Field<?>... fields)
Null-safety of a field.static <T> @NotNull Field<T>
nvl(Field<T> value, Field<T> defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function.static <T> @NotNull Field<T>
nvl(Field<T> value, T defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function.static <T> @NotNull Field<T>
nvl(T value, Field<T> defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function.static <T> @NotNull Field<T>
nvl(T value, T defaultValue)
Gets the Oracle-style NVL(value, defaultValue) function.static <Z> @NotNull Field<Z>
nvl2(Field<?> value, Field<Z> valueIfNotNull, Field<Z> valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.static <Z> @NotNull Field<Z>
nvl2(Field<?> value, Field<Z> valueIfNotNull, Z valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.static <Z> @NotNull Field<Z>
nvl2(Field<?> value, Z valueIfNotNull, Field<Z> valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.static <Z> @NotNull Field<Z>
nvl2(Field<?> value, Z valueIfNotNull, Z valueIfNull)
Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.static @NotNull Field<Integer>
octetLength(String value)
Get the octet_length(field) function.static @NotNull Field<Integer>
octetLength(Field<String> field)
Get the octet_length(field) function.static @NotNull Field<OffsetDateTime>
offsetDateTime(String value)
Convert a string value to aTIMESTAMP WITH TIME ZONE
.static @NotNull Field<OffsetDateTime>
offsetDateTime(OffsetDateTime value)
Convert a temporal value to aTIMESTAMP WITH TIME ZONE
.static @NotNull Field<OffsetDateTime>
offsetDateTime(Field<OffsetDateTime> field)
Convert a temporal value to aTIMESTAMP WITH TIME ZONE
.static @NotNull Field<OffsetTime>
offsetTime(String value)
Convert a string value to aTIME WITH TIME ZONE
.static @NotNull Field<OffsetTime>
offsetTime(OffsetTime value)
Convert a temporal value to aTIME WITH TIME ZONE
.static @NotNull Field<OffsetTime>
offsetTime(Field<OffsetTime> field)
Convert a temporal value to aTIME WITH TIME ZONE
.static @NotNull Param<Integer>
one()
A1
literal.static @NotNull Condition
or(Collection<? extends Condition> conditions)
static @NotNull Condition
or(Condition... conditions)
static @NotNull Condition
or(Condition left, Condition right)
static @NotNull WindowSpecificationRowsStep
orderBy(Collection<? extends OrderField<?>> fields)
Create aWindowSpecification
with anORDER BY
clause.static @NotNull WindowSpecificationRowsStep
orderBy(Field<?>... fields)
Create aWindowSpecification
with anORDER BY
clause.static @NotNull WindowSpecificationRowsStep
orderBy(OrderField<?>... fields)
Create aWindowSpecification
with anORDER BY
clause.static @NotNull Field<String>
overlay(Field<String> in, String placing, Number startIndex)
Get the overlay(in, placing, startIndex) function.static @NotNull Field<String>
overlay(Field<String> in, String placing, Number startIndex, Number length)
Get the overlay(in, placing, startIndex, length) function.static @NotNull Field<String>
overlay(Field<String> in, Field<String> placing, Field<? extends Number> startIndex)
Get the overlay(in, placing, startIndex) function.static @NotNull Field<String>
overlay(Field<String> in, Field<String> placing, Field<? extends Number> startIndex, Field<? extends Number> length)
Get the overlay(in, placing, startIndex, length) function.static <T> @NotNull Param<Object>
param()
Create an unnamed parameter with a generic type (Object
/SQLDataType.OTHER
) and no initial value.static <T> @NotNull Param<T>
param(Class<T> type)
Create an unnamed parameter with a defined type and no initial value.static @NotNull Param<Object>
param(String name)
Create a named parameter with a generic type (Object
/SQLDataType.OTHER
) and no initial value.static <T> @NotNull Param<T>
param(String name, Class<T> type)
Create a named parameter with a defined type and no initial value.static <T> @NotNull Param<T>
param(String name, DataType<T> type)
Create a named parameter with a defined type and no initial value.static <T> @NotNull Param<T>
param(String name, Field<T> type)
Create a named parameter with a defined type of another field and no initial value.static <T> @NotNull Param<T>
param(String name, T value)
Create a named parameter with an initial value.static <T> @NotNull Param<T>
param(DataType<T> type)
Create an unnamed parameter with a defined type and no initial value.static <T> @NotNull Param<T>
param(Field<T> field)
Create an unnamed parameter with the defined type of another field and no initial value.static @NotNull WindowSpecificationOrderByStep
partitionBy(Collection<? extends Field<?>> fields)
Create aWindowSpecification
with aPARTITION BY
clause.static @NotNull WindowSpecificationOrderByStep
partitionBy(Field<?>... fields)
Create aWindowSpecification
with aPARTITION BY
clause.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileCont(Number number)
Thepercentile_cont([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileCont(Field<? extends Number> field)
Thepercentile_cont([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileDisc(Number number)
Thepercentile_disc([number]) within group (order by [column])
function.static @NotNull OrderedAggregateFunction<BigDecimal>
percentileDisc(Field<? extends Number> field)
Thepercentile_disc([number]) within group (order by [column])
function.static @NotNull WindowOverStep<BigDecimal>
percentRank()
Theprecent_rank() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<Integer>
percentRank(Collection<? extends Field<?>> fields)
Thepercent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>
percentRank(Field<?>... fields)
Thepercent_rank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull Period<Timestamp>
period(Name name)
Create a namedPeriod
reference.static <T> @NotNull Period<T>
period(Name name, Class<T> type)
Create a namedPeriod
reference.static <T> @NotNull Period<T>
period(Name name, DataType<T> type)
Create a namedPeriod
reference.static @NotNull Field<BigDecimal>
pi()
Theπ
literal.static @NotNull Field<Integer>
position(String in, String search)
Get the position(in, search) function.static @NotNull Field<Integer>
position(String in, String search, int startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(String in, String search, Field<? extends Number> startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(String in, Field<String> search)
Get the position(in, search) function.static @NotNull Field<Integer>
position(String in, Field<String> search, int startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(String in, Field<String> search, Field<? extends Number> startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(Field<String> in, String search)
Get the position(in, search) function.static @NotNull Field<Integer>
position(Field<String> in, String search, int startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(Field<String> in, String search, Field<? extends Number> startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(Field<String> in, Field<String> search)
Get the position(in, search) function.static @NotNull Field<Integer>
position(Field<String> in, Field<String> search, int startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<Integer>
position(Field<String> in, Field<String> search, Field<? extends Number> startIndex)
Get the position(in, search, startindex) function.static @NotNull Field<BigDecimal>
power(Number value, Number exponent)
Get the power(field, exponent) function.static @NotNull Field<BigDecimal>
power(Number value, Field<? extends Number> exponent)
Get the power(field, exponent) function.static @NotNull Field<BigDecimal>
power(Field<? extends Number> field, Number exponent)
Get the power(field, exponent) function.static @NotNull Field<BigDecimal>
power(Field<? extends Number> field, Field<? extends Number> exponent)
Get the power(field, exponent) function.static @NotNull ConstraintEnforcementStep
primaryKey(String... fields)
Create an unnamed (system named)PRIMARY KEY
constraint.static @NotNull ConstraintEnforcementStep
primaryKey(Field<?>... fields)
Create an unnamed (system named)PRIMARY KEY
constraint.static @NotNull ConstraintEnforcementStep
primaryKey(Name... fields)
Create an unnamed (system named)PRIMARY KEY
constraint.static <T> @NotNull Field<T>
prior(Field<T> field)
Add the Oracle-specificPRIOR
unary operator before a field (to be used along withCONNECT BY
clauses).static @NotNull Privilege
privilege(String privilege)
Create a new privilege reference.static @NotNull AggregateFunction<BigDecimal>
product(Field<? extends Number> field)
Get the product over a numeric field: product(field).static @NotNull AggregateFunction<BigDecimal>
productDistinct(Field<? extends Number> field)
Get the sum over a numeric field: product(distinct field).static @NotNull Field<Integer>
quarter(Temporal value)
Get the quarter of a date.static @NotNull Field<Integer>
quarter(Date value)
Get the quarter of a date.static @NotNull Field<Integer>
quarter(Field<?> field)
Get the quarter of a date.static @NotNull Queries
queries(Collection<? extends Query> queries)
Wrap a collection of queries.static @NotNull Queries
queries(Query... queries)
Wrap a collection of queries.static @NotNull RowCountQuery
query(String sql)
Create a new query holding plain SQL.static @NotNull RowCountQuery
query(String sql, Object... bindings)
Create a new query holding plain SQL.static @NotNull RowCountQuery
query(String sql, QueryPart... parts)
Create a new query holding plain SQL.static @NotNull RowCountQuery
query(SQL sql)
Create a new query holding plain SQL.static @NotNull QueryPart
queryPart(String sql)
Deprecated.- 3.6.0 - [#3854] - Usesql(String)
insteadstatic @NotNull QueryPart
queryPart(String sql, Object... bindings)
Deprecated.- 3.6.0 - [#3854] - Usesql(String, Object...)
insteadstatic @NotNull QueryPart
queryPart(String sql, QueryPart... parts)
Deprecated.- 3.6.0 - [#3854] - Usesql(String, QueryPart...)
insteadstatic @NotNull Name
quotedName(String unqualifiedName)
Create a new SQL identifier using an unqualified, quoted name.static @NotNull Name
quotedName(String... qualifiedName)
Create a new SQL identifier using a qualified, quoted name.static @NotNull Name
quotedName(Collection<String> qualifiedName)
Create a new SQL identifier using a qualified, quoted name.static @NotNull Field<BigDecimal>
rad(Number value)
Calculate radians from degrees from this field.static @NotNull Field<BigDecimal>
rad(Field<? extends Number> field)
Calculate radians from degrees from this field.static @NotNull Field<BigDecimal>
rand()
Get the rand() function.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenCurrentRow()
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenFollowing(int number)
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenPreceding(int number)
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenUnboundedFollowing()
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationRowsAndStep
rangeBetweenUnboundedPreceding()
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangeCurrentRow()
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangeFollowing(int number)
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangePreceding(int number)
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangeUnboundedFollowing()
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowSpecificationExcludeStep
rangeUnboundedPreceding()
Create aWindowSpecification
with aRANGE
clause.static @NotNull WindowOverStep<Integer>
rank()
Therank() over ([analytic clause])
function.static @NotNull OrderedAggregateFunction<Integer>
rank(Collection<? extends Field<?>> fields)
Therank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull OrderedAggregateFunction<Integer>
rank(Field<?>... fields)
Therank(expr) within group (order by [order clause])
ordered-set aggregate function.static @NotNull WindowOverStep<BigDecimal>
ratioToReport(Number number)
Theratio_to_report([expression]) over ([analytic clause])
function.static @NotNull WindowOverStep<BigDecimal>
ratioToReport(Field<? extends Number> field)
Theratio_to_report([expression]) over ([analytic clause])
function.static <T1> @NotNull RecordType<Record>
recordType(Collection<? extends Field<?>> fields)
Create aRecordType
of an arbitrary degree.static <T1> @NotNull RecordType<Record>
recordType(Field<?>[] fields)
Create aRecordType
of an arbitrary degree.static <T1> @NotNull RecordType<Record1<T1>>
recordType(Field<T1> field1)
Create aRecordType
of degree1
.static <T1,T2>
@NotNull RecordType<Record2<T1,T2>>recordType(Field<T1> field1, Field<T2> field2)
Create aRecordType
of degree2
.static <T1,T2,T3>
@NotNull RecordType<Record3<T1,T2,T3>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3)
Create aRecordType
of degree3
.static <T1,T2,T3,T4>
@NotNull RecordType<Record4<T1,T2,T3,T4>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
Create aRecordType
of degree4
.static <T1,T2,T3,T4,T5>
@NotNull RecordType<Record5<T1,T2,T3,T4,T5>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
Create aRecordType
of degree5
.static <T1,T2,T3,T4,T5,T6>
@NotNull RecordType<Record6<T1,T2,T3,T4,T5,T6>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
Create aRecordType
of degree6
.static <T1,T2,T3,T4,T5,T6,T7>
@NotNull RecordType<Record7<T1,T2,T3,T4,T5,T6,T7>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
Create aRecordType
of degree7
.static <T1,T2,T3,T4,T5,T6,T7,T8>
@NotNull RecordType<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
Create aRecordType
of degree8
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9>
@NotNull RecordType<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
Create aRecordType
of degree9
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
@NotNull RecordType<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
Create aRecordType
of degree10
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
@NotNull RecordType<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
Create aRecordType
of degree11
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
@NotNull RecordType<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
Create aRecordType
of degree12
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
@NotNull RecordType<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
Create aRecordType
of degree13
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
@NotNull RecordType<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
Create aRecordType
of degree14
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
@NotNull RecordType<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
Create aRecordType
of degree15
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
@NotNull RecordType<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
Create aRecordType
of degree16
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
@NotNull RecordType<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
Create aRecordType
of degree17
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
@NotNull RecordType<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
Create aRecordType
of degree18
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
@NotNull RecordType<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
Create aRecordType
of degree19
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>
@NotNull RecordType<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
Create aRecordType
of degree20
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>
@NotNull RecordType<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
Create aRecordType
of degree21
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>
@NotNull RecordType<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
Create aRecordType
of degree22
.static @NotNull Field<String>
regexpReplaceAll(Field<String> field, String pattern, String replacement)
Get theREGEXP_REPLACE_ALL
function.static @NotNull Field<String>
regexpReplaceAll(Field<String> field, Field<String> pattern, Field<String> replacement)
Get theREGEXP_REPLACE_ALL
function.static @NotNull Field<String>
regexpReplaceFirst(Field<String> field, String pattern, String replacement)
Get theREGEXP_REPLACE_ALL
function.static @NotNull Field<String>
regexpReplaceFirst(Field<String> field, Field<String> pattern, Field<String> replacement)
Get theREGEXP_REPLACE_ALL
function.static @NotNull AggregateFunction<BigDecimal>
regrAvgX(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_AVGX
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrAvgY(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_AVGY
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrCount(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_COUNT
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrIntercept(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_INTERCEPT
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrR2(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_R2
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrSlope(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_SLOPE
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrSXX(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_SXX
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrSXY(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_SXY
linear regression function.static @NotNull AggregateFunction<BigDecimal>
regrSYY(Field<? extends Number> y, Field<? extends Number> x)
Get theREGR_SYY
linear regression function.static @NotNull Field<String>
repeat(String field, int count)
Get the repeat(field, count) function.static @NotNull Field<String>
repeat(String field, Field<? extends Number> count)
Get the repeat(field, count) function.static @NotNull RepeatUntilStep
repeat(Collection<? extends Statement> statements)
Create aREPEAT
loop for use in procedural code.static @NotNull Field<String>
repeat(Field<String> field, int count)
Get the repeat(count) function.static @NotNull Field<String>
repeat(Field<String> field, Field<? extends Number> count)
Get the repeat(field, count) function.static @NotNull RepeatUntilStep
repeat(Statement... statements)
Create aREPEAT
loop for use in procedural code.static @NotNull Field<String>
replace(Field<String> field, String search)
Get the replace(field, search) function.static @NotNull Field<String>
replace(Field<String> field, String search, String replace)
Get the replace(field, search, replace) function.static @NotNull Field<String>
replace(Field<String> field, Field<String> search)
Get the replace(field, search) function.static @NotNull Field<String>
replace(Field<String> field, Field<String> search, Field<String> replace)
Get the replace(field, search, replace) function.static @NotNull ResultQuery<Record>
resultQuery(String sql)
Create a new query holding plain SQL.static @NotNull ResultQuery<Record>
resultQuery(String sql, Object... bindings)
Create a new query holding plain SQL.static @NotNull ResultQuery<Record>
resultQuery(String sql, QueryPart... parts)
Create a new query holding plain SQL.static @NotNull ResultQuery<Record>
resultQuery(SQL sql)
Create a new query holding plain SQL.static @NotNull Statement
return_()
Create anRETURN
statement for use in procedural code.static @NotNull Statement
return_(Object value)
Create anRETURN
statement for use in procedural code.static @NotNull Statement
return_(Field<?> value)
Create anRETURN
statement for use in procedural code.static @NotNull Field<String>
reverse(String value)
Get thereverse(field)
function.static @NotNull Field<String>
reverse(Field<String> field)
Get thereverse(field)
function.static RevokeOnStep
revoke(Collection<? extends Privilege> privileges)
TheREVOKE
statement.static RevokeOnStep
revoke(Privilege privileges)
TheREVOKE
statement.static RevokeOnStep
revoke(Privilege... privileges)
TheREVOKE
statement.static RevokeOnStep
revokeGrantOptionFor(Collection<? extends Privilege> privileges)
TheREVOKE GRANT OPTION FOR
statement.static RevokeOnStep
revokeGrantOptionFor(Privilege privileges)
TheREVOKE GRANT OPTION FOR
statement.static RevokeOnStep
revokeGrantOptionFor(Privilege... privileges)
TheREVOKE GRANT OPTION FOR
statement.static @NotNull Field<String>
right(String field, int length)
Get the right outermost characters from a string.static @NotNull Field<String>
right(String field, Field<? extends Number> length)
Get the right outermost characters from a string.static @NotNull Field<String>
right(Field<String> field, int length)
Get the right outermost characters from a string.static @NotNull Field<String>
right(Field<String> field, Field<? extends Number> length)
Get the right outermost characters from a string.static @NotNull Role
role(String name)
Create a new role reference.static @NotNull Role
role(Name name)
Create a new role reference.static @NotNull GroupField
rollup(Field<?>... fields)
Create a ROLLUP(field1, field2, .., fieldn) grouping field.static @NotNull GroupField
rollup(FieldOrRow... fields)
Create a ROLLUP(field1, field2, .., fieldn) grouping field.static <T extends Number>
@NotNull Field<T>round(Field<T> field)
Get rounded value of a numeric field: round(field).static <T extends Number>
@NotNull Field<T>round(Field<T> field, int decimals)
Get rounded value of a numeric field: round(field, decimals).static <T extends Number>
@NotNull Field<T>round(Field<T> field, Field<Integer> decimals)
Get rounded value of a numeric field: round(field, decimals).static <T extends Number>
@NotNull Field<T>round(T value)
Get rounded value of a numeric field: round(field).static <T extends Number>
@NotNull Field<T>round(T value, int decimals)
Get rounded value of a numeric field: round(field, decimals).static @NotNull RowN
row(Object... values)
Create a row value expression of degreeN > 22
.static @NotNull RowN
row(Collection<?> values)
Create a row value expression of degreeN > 22
.static @NotNull RowN
row(Field<?>... values)
Create a row value expression of degreeN > 22
.static <T1> @NotNull Row1<T1>
row(Field<T1> t1)
Create a row value expression of degree1
.static <T1,T2>
@NotNull Row2<T1,T2>row(Field<T1> t1, Field<T2> t2)
Create a row value expression of degree2
.static <T1,T2,T3>
@NotNull Row3<T1,T2,T3>row(Field<T1> t1, Field<T2> t2, Field<T3> t3)
Create a row value expression of degree3
.static <T1,T2,T3,T4>
@NotNull Row4<T1,T2,T3,T4>row(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4)
Create a row value expression of degree4
.static <T1,T2,T3,T4,T5>
@NotNull Row5<T1,T2,T3,T4,T5>row(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4, Field<T5> t5)
Create a row value expression of degree5
.static <T1,T2,T3,T4,T5,T6>
@NotNull Row6<T1,T2,T3,T4,T5,T6>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 degree6
.static <T1,T2,T3,T4,T5,T6,T7>
@NotNull Row7<T1,T2,T3,T4,T5,T6,T7>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 degree7
.static <T1,T2,T3,T4,T5,T6,T7,T8>
@NotNull Row8<T1,T2,T3,T4,T5,T6,T7,T8>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 degree8
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9>
@NotNull Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9>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, Field<T9> t9)
Create a row value expression of degree9
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
@NotNull Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>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, Field<T9> t9, Field<T10> t10)
Create a row value expression of degree10
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
@NotNull Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>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, Field<T9> t9, Field<T10> t10, Field<T11> t11)
Create a row value expression of degree11
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
@NotNull Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>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, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12)
Create a row value expression of degree12
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
@NotNull Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>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, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13)
Create a row value expression of degree13
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
@NotNull Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>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, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14)
Create a row value expression of degree14
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
@NotNull Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>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, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15)
Create a row value expression of degree15
.static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
@NotNull Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>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, Field<T9> t9, Field<T10> t10, Field<T11> t11, Field<T12> t12, Field<T13> t13, Field<T14> t14, Field<T15> t15, Field<T16> t16)
-