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 the org.jooq interfaces.
The DSLContext and this DSL 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 a Field 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 any SELECT to form a Condition:
```
 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> Field<T>`	`abs(Field<T> field)`	Get the absolute value of a numeric field: abs(field).
`static <T extends Number> Field<T>`	`abs(T value)`	Get the absolute value of a numeric field: abs(field).
`static Field<BigDecimal>`	`acos(Number value)`	Get the arc cosine(field) function.
`static Field<BigDecimal>`	`acos(Field<? extends Number> field)`	Get the arc cosine(field) function.
`static <T> QuantifiedSelect<Record1<T>>`	`all(Field<T[]> array)`	Create an `ALL` quantified select to be used in quantified comparison predicate expressions.
`static <T> QuantifiedSelect<Record1<T>>`	`all(Field<T>... fields)`	Create an `ALL` quantified select to be used in quantified comparison predicate expressions.
`static <R extends Record> QuantifiedSelect<R>`	`all(Select<R> select)`	Create an `ALL` quantified select to be used in quantified comparison predicate expressions.
`static <T> QuantifiedSelect<Record1<T>>`	`all(T... array)`	Create an `ALL` quantified select to be used in quantified comparison predicate expressions.
`static AlterIndexOnStep`	`alterIndex(String index)`	Create a new DSL `ALTER INDEX` statement.
`static AlterIndexOnStep`	`alterIndex(Index index)`	Create a new DSL `ALTER INDEX` statement.
`static AlterIndexOnStep`	`alterIndex(Name index)`	Create a new DSL `ALTER INDEX` statement.
`static AlterIndexStep`	`alterIndexIfExists(String index)`	Create a new DSL `ALTER INDEX` statement.
`static AlterIndexStep`	`alterIndexIfExists(Index index)`	Create a new DSL `ALTER INDEX` statement.
`static AlterIndexStep`	`alterIndexIfExists(Name index)`	Create a new DSL `ALTER INDEX` statement.
`static AlterSchemaStep`	`alterSchema(String schema)`	Create a new DSL `ALTER SCHEMA` statement.
`static AlterSchemaStep`	`alterSchema(Name schema)`	Create a new DSL `ALTER SCHEMA` statement.
`static AlterSchemaStep`	`alterSchema(Schema schema)`	Create a new DSL `ALTER SCHEMA` statement.
`static AlterSchemaStep`	`alterSchemaIfExists(String schema)`	Create a new DSL `ALTER SCHEMA` statement.
`static AlterSchemaStep`	`alterSchemaIfExists(Name schema)`	Create a new DSL `ALTER SCHEMA` statement.
`static AlterSchemaStep`	`alterSchemaIfExists(Schema schema)`	Create a new DSL `ALTER SCHEMA` statement.
`static AlterSequenceStep<BigInteger>`	`alterSequence(String sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`static AlterSequenceStep<BigInteger>`	`alterSequence(Name sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`static <T extends Number> AlterSequenceStep<T>`	`alterSequence(Sequence<T> sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`static AlterSequenceStep<BigInteger>`	`alterSequenceIfExists(String sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`static AlterSequenceStep<BigInteger>`	`alterSequenceIfExists(Name sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`static <T extends Number> AlterSequenceStep<T>`	`alterSequenceIfExists(Sequence<T> sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`static AlterTableStep`	`alterTable(String table)`	Create a new DSL `ALTER TABLE` statement.
`static AlterTableStep`	`alterTable(Name table)`	Create a new DSL `ALTER TABLE` statement.
`static AlterTableStep`	`alterTable(Table<?> table)`	Create a new DSL `ALTER TABLE` statement.
`static AlterTableStep`	`alterTableIfExists(String table)`	Create a new DSL `ALTER TABLE` statement.
`static AlterTableStep`	`alterTableIfExists(Name table)`	Create a new DSL `ALTER TABLE` statement.
`static AlterTableStep`	`alterTableIfExists(Table<?> table)`	Create a new DSL `ALTER TABLE` statement.
`static AlterViewStep`	`alterView(String view)`	Create a new DSL `ALTER VIEW` statement.
`static AlterViewStep`	`alterView(Name view)`	Create a new DSL `ALTER VIEW` statement.
`static AlterViewStep`	`alterView(Table<?> view)`	Create a new DSL `ALTER VIEW` statement.
`static AlterViewStep`	`alterViewIfExists(String view)`	Create a new DSL `ALTER VIEW` statement.
`static AlterViewStep`	`alterViewIfExists(Name view)`	Create a new DSL `ALTER VIEW` statement.
`static AlterViewStep`	`alterViewIfExists(Table<?> view)`	Create a new DSL `ALTER VIEW` statement.
`static Condition`	`and(Collection<? extends Condition> conditions)`	Return a `Condition` that connects all argument `conditions` with `Operator.AND`.
`static Condition`	`and(Condition... conditions)`	Return a `Condition` that connects all argument `conditions` with `Operator.AND`.
`static Condition`	`and(Condition left, Condition right)`	Return a `Condition` that connects all argument `conditions` with `Operator.AND`.
`static <T> QuantifiedSelect<Record1<T>>`	`any(Field<T[]> array)`	Create an `ANY` quantified select to be used in quantified comparison predicate expressions.
`static <T> QuantifiedSelect<Record1<T>>`	`any(Field<T>... fields)`	Create an `ANY` quantified select to be used in quantified comparison predicate expressions.
`static <R extends Record> QuantifiedSelect<R>`	`any(Select<R> select)`	Create an `ANY` quantified select to be used in quantified comparison predicate expressions.
`static <T> QuantifiedSelect<Record1<T>>`	`any(T... array)`	Create an `ANY` quantified select to be used in quantified comparison predicate expressions.
`static <T> Field<T[]>`	`array(Collection<? extends Field<T>> fields)`	Create an array literal.
`static <T> Field<T[]>`	`array(Field<T>... fields)`	Create an array literal.
`static <T> Field<T[]>`	`array(T... values)`	Create an array literal.
`static <T> ArrayAggOrderByStep<T[]>`	`arrayAgg(Field<T> field)`	Get the `array_agg()` aggregate function.
`static <T> ArrayAggOrderByStep<T[]>`	`arrayAggDistinct(Field<T> field)`	Get the `array_agg()` aggregate function.
`static Field<Integer>`	`ascii(String field)`	Get the ascii(field) function.
`static Field<Integer>`	`ascii(Field<String> field)`	Get the ascii(field) function.
`static Field<BigDecimal>`	`asin(Number value)`	Get the arc sine(field) function.
`static Field<BigDecimal>`	`asin(Field<? extends Number> field)`	Get the arc sine(field) function.
`static Asterisk`	`asterisk()`	The asterisk (`*`) to be used in `SELECT` clauses.
`static Field<BigDecimal>`	`atan(Number value)`	Get the arc tangent(field) function.
`static Field<BigDecimal>`	`atan(Field<? extends Number> field)`	Get the arc tangent(field) function.
`static Field<BigDecimal>`	`atan2(Number x, Number y)`	Get the atan2(field, y) function.
`static Field<BigDecimal>`	`atan2(Number x, Field<? extends Number> y)`	Get the atan2(field, y) function.
`static Field<BigDecimal>`	`atan2(Field<? extends Number> x, Number y)`	Get the atan2(field, y) function.
`static Field<BigDecimal>`	`atan2(Field<? extends Number> x, Field<? extends Number> y)`	Get the atan2(field, y) function.
`static AggregateFunction<BigDecimal>`	`avg(Field<? extends Number> field)`	Get the average over a numeric field: avg(field).
`static AggregateFunction<BigDecimal>`	`avgDistinct(Field<? extends Number> field)`	Get the average over a numeric field: avg(distinct field).
`static Block`	`begin(Collection<? extends Statement> statements)`	Wrap a collection of statements in an anonymous procedural block.
`static Block`	`begin(Statement... statements)`	Wrap a collection of statements in an anonymous procedural block.
`static <T extends Number> Field<T>`	`bitAnd(Field<T> field1, Field<T> field2)`	The bitwise and operator.
`static <T extends Number> Field<T>`	`bitAnd(Field<T> value1, T value2)`	The bitwise and operator.
`static <T extends Number> Field<T>`	`bitAnd(T value1, Field<T> value2)`	The bitwise and operator.
`static <T extends Number> Field<T>`	`bitAnd(T value1, T value2)`	The bitwise and operator.
`static Field<Integer>`	`bitCount(Number value)`	The MySQL `BIT_COUNT(field)` function, counting the number of bits that are set in this number.
`static Field<Integer>`	`bitCount(Field<? extends Number> field)`	The MySQL `BIT_COUNT(field)` function, counting the number of bits that are set in this number.
`static Field<Integer>`	`bitLength(String value)`	Get the bit_length(field) function.
`static Field<Integer>`	`bitLength(Field<String> field)`	Get the bit_length(field) function.
`static <T extends Number> Field<T>`	`bitNand(Field<T> field1, Field<T> field2)`	The bitwise not and operator.
`static <T extends Number> Field<T>`	`bitNand(Field<T> value1, T value2)`	The bitwise not and operator.
`static <T extends Number> Field<T>`	`bitNand(T value1, Field<T> value2)`	The bitwise not and operator.
`static <T extends Number> Field<T>`	`bitNand(T value1, T value2)`	The bitwise not and operator.
`static <T extends Number> Field<T>`	`bitNor(Field<T> field1, Field<T> field2)`	The bitwise not or operator.
`static <T extends Number> Field<T>`	`bitNor(Field<T> value1, T value2)`	The bitwise not or operator.
`static <T extends Number> Field<T>`	`bitNor(T value1, Field<T> value2)`	The bitwise not or operator.
`static <T extends Number> Field<T>`	`bitNor(T value1, T value2)`	The bitwise not or operator.
`static <T extends Number> Field<T>`	`bitNot(Field<T> field)`	The bitwise not operator.
`static <T extends Number> Field<T>`	`bitNot(T value)`	The bitwise not operator.
`static <T extends Number> Field<T>`	`bitOr(Field<T> field1, Field<T> field2)`	The bitwise or operator.
`static <T extends Number> Field<T>`	`bitOr(Field<T> value1, T value2)`	The bitwise or operator.
`static <T extends Number> Field<T>`	`bitOr(T value1, Field<T> value2)`	The bitwise or operator.
`static <T extends Number> Field<T>`	`bitOr(T value1, T value2)`	The bitwise or operator.
`static <T extends Number> Field<T>`	`bitXNor(Field<T> field1, Field<T> field2)`	The bitwise not xor operator.
`static <T extends Number> Field<T>`	`bitXNor(Field<T> value1, T value2)`	The bitwise not xor operator.
`static <T extends Number> Field<T>`	`bitXNor(T value1, Field<T> value2)`	The bitwise not xor operator.
`static <T extends Number> Field<T>`	`bitXNor(T value1, T value2)`	The bitwise not xor operator.
`static <T extends Number> Field<T>`	`bitXor(Field<T> field1, Field<T> field2)`	The bitwise xor operator.
`static <T extends Number> Field<T>`	`bitXor(Field<T> value1, T value2)`	The bitwise xor operator.
`static <T extends Number> Field<T>`	`bitXor(T value1, Field<T> value2)`	The bitwise xor operator.
`static <T extends Number> Field<T>`	`bitXor(T value1, T value2)`	The bitwise xor operator.
`static AggregateFunction<Boolean>`	`boolAnd(Condition condition)`	Get the every value over a condition: bool_and(condition).
`static AggregateFunction<Boolean>`	`boolAnd(Field<Boolean> field)`	Get the every value over a field: bool_and(field).
`static AggregateFunction<Boolean>`	`boolOr(Condition condition)`	Get the every value over a condition: bool_and(condition).
`static AggregateFunction<Boolean>`	`boolOr(Field<Boolean> field)`	Get the every value over a field: bool_and(field).
`static Case`	`case_()`	Initialise a `Case` statement.
`static <V> CaseValueStep<V>`	`case_(Field<V> value)`	Initialise a `Case` statement.
`static <V> CaseValueStep<V>`	`case_(V value)`	Initialise a `Case` statement.
`static <T> Field<T>`	`cast(Object value, Class<T> type)`	Cast a value to another type.
`static <T> Field<T>`	`cast(Object value, DataType<T> type)`	Cast a value to another type.
`static <T> Field<T>`	`cast(Object value, Field<T> as)`	Cast a value to the type of another field.
`static <T> Field<T>`	`cast(Field<?> field, Class<T> type)`	Cast a field to another type.
`static <T> Field<T>`	`cast(Field<?> field, DataType<T> type)`	Cast a field to another type.
`static <T> Field<T>`	`cast(Field<?> field, Field<T> as)`	Cast a field to the type of another field.
`static <T> Field<T>`	`castNull(Class<T> type)`	Cast null to a type.
`static <T> Field<T>`	`castNull(DataType<T> type)`	Cast null to a type.
`static <T> Field<T>`	`castNull(Field<T> as)`	Cast null to the type of another field.
`static Catalog`	`catalog(Name name)`	Create a qualified catalog, given its catalog name.
`static <T extends Number> Field<T>`	`ceil(Field<T> field)`	Get the smallest integer value not less than [field].
`static <T extends Number> Field<T>`	`ceil(T value)`	Get the smallest integer value not less than [this].
`static Field<Integer>`	`century(Temporal value)`	Get the century of a date.
`static Field<Integer>`	`century(Date value)`	Get the century of a date.
`static Field<Integer>`	`century(Field<?> field)`	Get the century of a date.
`static CharacterSet`	`characterSet(String characterSet)`	Create a character set by its unqualified name.
`static CharacterSet`	`characterSet(Name characterSet)`	Create a character set by its qualified name.
`static Field<Integer>`	`charLength(String value)`	Get the char_length(field) function.
`static Field<Integer>`	`charLength(Field<String> field)`	Get the char_length(field) function.
`static ConstraintFinalStep`	`check(Condition condition)`	Create an unnamed (system named) `CHECK` constraint.
`static Case`	`choose()`	Initialise a `Case` statement.
`static <T> Field<T>`	`choose(int index, Field<T>... values)`	The T-SQL `CHOOSE()` function.
`static <T> Field<T>`	`choose(int index, T... values)`	The T-SQL `CHOOSE()` function.
`static <T> Field<T>`	`choose(Field<Integer> index, Field<T>... values)`	The T-SQL `CHOOSE()` function.
`static <T> Field<T>`	`choose(Field<Integer> index, T... values)`	The T-SQL `CHOOSE()` function.
`static <V> CaseValueStep<V>`	`choose(Field<V> value)`	Initialise a `Case` statement.
`static <V> CaseValueStep<V>`	`choose(V value)`	Initialise a `Case` statement.
`static <T> Field<T>`	`coalesce(Field<T> field, Field<?>... fields)`	The `COALESCE(field1, field2, ...`
`static <T> Field<T>`	`coalesce(Field<T> field, T value)`	The `COALESCE(field, value)` function.
`static <T> Field<T>`	`coalesce(T value, T... values)`	The `COALESCE(value1, value2, ...`
`static <T> Field<T>`	`coerce(Object value, Class<T> as)`	Coerce this field to another type.
`static <T> Field<T>`	`coerce(Object value, DataType<T> as)`	Coerce a field to another type.
`static <T> Field<T>`	`coerce(Object value, Field<T> as)`	Coerce this field to the type of another field.
`static <T> Field<T>`	`coerce(Field<?> field, Class<T> as)`	Coerce this field to another type.
`static <T> Field<T>`	`coerce(Field<?> field, DataType<T> as)`	Coerce a field to another type.
`static <T> Field<T>`	`coerce(Field<?> field, Field<T> as)`	Coerce this field to the type of another field.
`static Collation`	`collation(String collation)`	Create a collation by its unqualified name.
`static Collation`	`collation(Name collation)`	Create a collation by its qualified name.
`static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A>`	`collect(Field<T> field, Class<A> type)`	Get the `collect()` aggregate function.
`static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A>`	`collect(Field<T> field, DataType<A> type)`	Get the `collect()` aggregate function.
`static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A>`	`collectDistinct(Field<T> field, Class<A> type)`	Get the `collect()` aggregate function.
`static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A>`	`collectDistinct(Field<T> field, DataType<A> type)`	Get the `collect()` aggregate function.
`static Comment`	`comment(String comment)`	Create a comment.
`static CommentOnIsStep`	`commentOnColumn(Field<?> field)`	Create a new DSL `COMMENT ON COLUMN` statement.
`static CommentOnIsStep`	`commentOnColumn(Name columnName)`	Create a new DSL `COMMENT ON COLUMN` statement.
`static CommentOnIsStep`	`commentOnTable(String tableName)`	Create a new DSL `COMMENT ON TABLE` statement.
`static CommentOnIsStep`	`commentOnTable(Name tableName)`	Create a new DSL `COMMENT ON TABLE` statement.
`static CommentOnIsStep`	`commentOnTable(Table<?> table)`	Create a new DSL `COMMENT ON TABLE` statement.
`static CommentOnIsStep`	`commentOnView(String viewName)`	Create a new DSL `COMMENT ON VIEW` statement.
`static CommentOnIsStep`	`commentOnView(Name viewName)`	Create a new DSL `COMMENT ON VIEW` statement.
`static CommentOnIsStep`	`commentOnView(Table<?> view)`	Create a new DSL `COMMENT ON VIEW` statement.
`static Field<String>`	`concat(String... values)`	Get the concat(value[, value, ...]) function.
`static Field<String>`	`concat(String value, Field<String> field)`	Get the `concat(value, field)` function.
`static Field<String>`	`concat(Field<?>... fields)`	Get the concat(field[, field, ...]) function.
`static Field<String>`	`concat(Field<String> field, String value)`	Get the `concat(field, value)` function.
`static Condition`	`condition(Boolean value)`	Create a condition from a boolean field.
`static Condition`	`condition(String sql)`	Create a new condition holding plain SQL.
`static Condition`	`condition(String sql, Object... bindings)`	Create a new condition holding plain SQL.
`static Condition`	`condition(String sql, QueryPart... parts)`	A custom SQL clause that can render arbitrary SQL elements.
`static Condition`	`condition(Map<Field<?>,?> map)`	Create a condition from a map.
`static Condition`	`condition(Field<Boolean> field)`	Create a condition from a boolean field.
`static Condition`	`condition(Operator operator, Collection<? extends Condition> conditions)`	Return a `Condition` that connects all argument `conditions` with `Operator`.
`static Condition`	`condition(Operator operator, Condition... conditions)`	Return a `Condition` that connects all argument `conditions` with `Operator`.
`static Condition`	`condition(Operator operator, Condition left, Condition right)`	Return a `Condition` that connects all argument `conditions` with `Operator`.
`static Condition`	`condition(Record record)`	Create a "Query By Example" (QBE) `Condition` from a `Record` .
`static Condition`	`condition(SQL sql)`	Create a new condition holding plain SQL.
`static Field<Boolean>`	`connectByIsCycle()`	Retrieve the Oracle-specific `CONNECT_BY_ISCYCLE` pseudo-field (to be used along with `CONNECT BY` clauses).
`static Field<Boolean>`	`connectByIsLeaf()`	Retrieve the Oracle-specific `CONNECT_BY_ISLEAF` pseudo-field (to be used along with `CONNECT BY` clauses).
`static <T> Field<T>`	`connectByRoot(Field<T> field)`	Retrieve the Oracle-specific `CONNECT_BY_ROOT` pseudo-column (to be used along with `CONNECT BY` clauses).
`static ConstraintTypeStep`	`constraint()`	Create an unnamed (system named) `CONSTRAINT` specification.
`static ConstraintTypeStep`	`constraint(String name)`	Create a `CONSTRAINT` specification.
`static ConstraintTypeStep`	`constraint(Name name)`	Create a `CONSTRAINT` specification.
`static ContinueWhenStep`	`continue_()`	Create an `CONTINUE` statement for use in procedural code.
`static ContinueWhenStep`	`continue_(Label label)`	Create an `CONTINUE` statement for use in procedural code.
`static Statement`	`continueWhen(Condition condition)`	Create an `CONTINUE` statement for use in procedural code.
`static <T> Field<T>`	`convert(DataType<T> type, Object value, int style)`	Convert a date time value to a string value using the SQL Server style `CONVERT()` function.
`static <T> Field<T>`	`convert(DataType<T> type, Field<?> value, int style)`	Convert a date time value to a string value using the SQL Server style `CONVERT()` function.
`static Field<BigDecimal>`	`cos(Number value)`	Get the cosine(field) function.
`static Field<BigDecimal>`	`cos(Field<? extends Number> field)`	Get the cosine(field) function.
`static Field<BigDecimal>`	`cosh(Number value)`	Get the hyperbolic cosine function: cosh(field).
`static Field<BigDecimal>`	`cosh(Field<? extends Number> field)`	Get the hyperbolic cosine function: cosh(field).
`static Field<BigDecimal>`	`cot(Number value)`	Get the cotangent(field) function.
`static Field<BigDecimal>`	`cot(Field<? extends Number> field)`	Get the cotangent(field) function.
`static Field<BigDecimal>`	`coth(Number value)`	Get the hyperbolic cotangent function: coth(field).
`static Field<BigDecimal>`	`coth(Field<? extends Number> field)`	Get the hyperbolic cotangent function: coth(field).
`static AggregateFunction<Integer>`	`count()`	Get the count(*) function.
`static AggregateFunction<Integer>`	`count(Field<?> field)`	Get the count(field) function.
`static AggregateFunction<Integer>`	`count(SelectFieldOrAsterisk field)`	Get the count(field) function.
`static AggregateFunction<Integer>`	`count(Table<?> table)`	Get the count(table) function.
`static AggregateFunction<Integer>`	`countDistinct(Field<?> field)`	Get the count(distinct field) function.
`static AggregateFunction<Integer>`	`countDistinct(Field<?>... fields)`	Get the count(distinct field1, field2) function.
`static AggregateFunction<Integer>`	`countDistinct(SelectFieldOrAsterisk field)`	Get the count(distinct field) function.
`static AggregateFunction<Integer>`	`countDistinct(Table<?> table)`	Get the count(distinct table) function.
`static CreateTableColumnStep`	`createGlobalTemporaryTable(String table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`static CreateTableColumnStep`	`createGlobalTemporaryTable(Name table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`static CreateTableColumnStep`	`createGlobalTemporaryTable(Table<?> table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`static CreateIndexStep`	`createIndex()`	Create a new DSL `CREATE INDEX` statement.
`static CreateIndexStep`	`createIndex(String index)`	Create a new DSL `CREATE INDEX` statement.
`static CreateIndexStep`	`createIndex(Index index)`	Create a new DSL `CREATE INDEX` statement.
`static CreateIndexStep`	`createIndex(Name index)`	Create a new DSL `CREATE INDEX` statement.
`static CreateIndexStep`	`createIndexIfNotExists(String index)`	Create a new DSL `CREATE INDEX IF NOT EXISTS` statement.
`static CreateIndexStep`	`createIndexIfNotExists(Index index)`	Create a new DSL `CREATE INDEX IF NOT EXISTS` statement.
`static CreateIndexStep`	`createIndexIfNotExists(Name index)`	Create a new DSL `CREATE INDEX IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createOrReplaceView(String view, String... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`static CreateViewAsStep`	`createOrReplaceView(String view, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`static CreateViewAsStep`	`createOrReplaceView(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`static CreateViewAsStep`	`createOrReplaceView(Name view, Name... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`static CreateViewAsStep`	`createOrReplaceView(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`static CreateViewAsStep`	`createOrReplaceView(Table<?> view, Field<?>... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`static CreateSchemaFinalStep`	`createSchema(String schema)`	Create a new DSL `CREATE SCHEMA` statement.
`static CreateSchemaFinalStep`	`createSchema(Name schema)`	Create a new DSL `CREATE SCHEMA` statement.
`static CreateSchemaFinalStep`	`createSchema(Schema schema)`	Create a new DSL `CREATE SCHEMA` statement.
`static CreateSchemaFinalStep`	`createSchemaIfNotExists(String schema)`	Create a new DSL `CREATE SCHEMA` statement.
`static CreateSchemaFinalStep`	`createSchemaIfNotExists(Name table)`	Create a new DSL `CREATE SCHEMA` statement.
`static CreateSchemaFinalStep`	`createSchemaIfNotExists(Schema schema)`	Create a new DSL `CREATE SCHEMA` statement.
`static CreateSequenceFlagsStep`	`createSequence(String sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`static CreateSequenceFlagsStep`	`createSequence(Name sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`static CreateSequenceFlagsStep`	`createSequence(Sequence<?> sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`static CreateSequenceFlagsStep`	`createSequenceIfNotExists(String sequence)`	Create a new DSL `CREATE SEQUENCE IF NOT EXISTS` statement.
`static CreateSequenceFlagsStep`	`createSequenceIfNotExists(Name sequence)`	Create a new DSL `CREATE SEQUENCE IF NOT EXISTS` statement.
`static CreateSequenceFlagsStep`	`createSequenceIfNotExists(Sequence<?> sequence)`	Create a new DSL `CREATE SEQUENCE IF NOT EXISTS` statement.
`static CreateTableColumnStep`	`createTable(String table)`	Create a new DSL `CREATE TABLE` statement.
`static CreateTableColumnStep`	`createTable(Name table)`	Create a new DSL `CREATE TABLE` statement.
`static CreateTableColumnStep`	`createTable(Table<?> table)`	Create a new DSL `CREATE TABLE` statement.
`static CreateTableColumnStep`	`createTableIfNotExists(String table)`	Create a new DSL `CREATE TABLE` statement.
`static CreateTableColumnStep`	`createTableIfNotExists(Name table)`	Create a new DSL `CREATE TABLE` statement.
`static CreateTableColumnStep`	`createTableIfNotExists(Table<?> table)`	Create a new DSL `CREATE TABLE` statement.
`static CreateTableColumnStep`	`createTemporaryTable(String table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`static CreateTableColumnStep`	`createTemporaryTable(Name table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`static CreateTableColumnStep`	`createTemporaryTable(Table<?> table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`static CreateTypeStep`	`createType(String type)`	Create a new DSL `CREATE TYPE` statement.
`static CreateTypeStep`	`createType(Name type)`	Create a new DSL `CREATE TYPE` statement.
`static CreateIndexStep`	`createUniqueIndex()`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`static CreateIndexStep`	`createUniqueIndex(String index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`static CreateIndexStep`	`createUniqueIndex(Index index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`static CreateIndexStep`	`createUniqueIndex(Name index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`static CreateIndexStep`	`createUniqueIndexIfNotExists(String index)`	Create a new DSL `CREATE UNIQUE INDEX IF NOT EXISTS` statement.
`static CreateIndexStep`	`createUniqueIndexIfNotExists(Index index)`	Create a new DSL `CREATE UNIQUE INDEX IF NOT EXISTS` statement.
`static CreateIndexStep`	`createUniqueIndexIfNotExists(Name index)`	Create a new DSL `CREATE UNIQUE INDEX IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createView(String view, String... fields)`	Create a new DSL `CREATE VIEW` statement.
`static CreateViewAsStep`	`createView(String view, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`static CreateViewAsStep`	`createView(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`static CreateViewAsStep`	`createView(Name view, Name... fields)`	Create a new DSL `CREATE VIEW` statement.
`static CreateViewAsStep`	`createView(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`static CreateViewAsStep`	`createView(Table<?> view, Field<?>... fields)`	Create a new DSL `CREATE VIEW` statement.
`static CreateViewAsStep`	`createViewIfNotExists(String view, String... fields)`	Create a new DSL `CREATE VIEW IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createViewIfNotExists(String view, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a new DSL `CREATE VIEW IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createViewIfNotExists(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createViewIfNotExists(Name view, Name... fields)`	Create a new DSL `CREATE VIEW IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createViewIfNotExists(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW IF NOT EXISTS` statement.
`static CreateViewAsStep`	`createViewIfNotExists(Table<?> view, Field<?>... fields)`	Create a new DSL `CREATE VIEW IF NOT EXISTS` statement.
`static GroupField`	`cube(Field<?>... fields)`	Create a CUBE(field1, field2, .., fieldn) grouping field.
`static GroupField`	`cube(FieldOrRow... fields)`	Create a CUBE(field1, field2, .., fieldn) grouping field.
`static WindowOverStep<BigDecimal>`	`cumeDist()`	The `cume_dist() over ([analytic clause])` function.
`static OrderedAggregateFunction<BigDecimal>`	`cumeDist(Collection<? extends Field<?>> fields)`	The `cume_dist(expr) within group (order by [order clause])` ordered-set aggregate function.
`static OrderedAggregateFunction<BigDecimal>`	`cumeDist(Field<?>... fields)`	The `cume_dist(expr) within group (order by [order clause])` ordered-set aggregate function.
`static Field<Date>`	`currentDate()`	Get the current_date() function returning a SQL standard `SQLDataType.DATE` type.
`static Field<Instant>`	`currentInstant()`	Get the current_timestamp() function.
`static Field<LocalDate>`	`currentLocalDate()`	Get the current_date() function returning a SQL standard `SQLDataType.DATE` type.
`static Field<LocalDateTime>`	`currentLocalDateTime()`	Get the current_timestamp() function returning a SQL standard `SQLDataType.TIMESTAMP` type.
`static Field<LocalTime>`	`currentLocalTime()`	Get the current_time() function returning a SQL standard `SQLDataType.TIME` type.
`static Field<OffsetDateTime>`	`currentOffsetDateTime()`	Get the current_timestamp() function.
`static Field<OffsetTime>`	`currentOffsetTime()`	Get the current_time() function.
`static Field<String>`	`currentSchema()`	Get the `current_schema()` function.
`static Field<Time>`	`currentTime()`	Get the current_time() function returning a SQL standard `SQLDataType.TIME` type.
`static Field<Timestamp>`	`currentTimestamp()`	Get the current_timestamp() function returning a SQL standard `SQLDataType.TIMESTAMP` type.
`static Field<Timestamp>`	`currentTimestamp(Field<Integer> precision)`	Get the current_timestamp() function returning a SQL standard `SQLDataType.TIMESTAMP` type with the specified fractional seconds precision.
`static Field<String>`	`currentUser()`	Get the `current_user()` function.
`static Field<Date>`	`date(String value)`	Convert a string value to a `DATE`.
`static Field<Date>`	`date(Date value)`	Convert a temporal value to a `DATE`.
`static Field<Date>`	`date(Field<? extends Date> field)`	Convert a temporal value to a `DATE`.
`static Field<Date>`	`dateAdd(Date date, Number interval)`	Add an interval to a date.
`static Field<Date>`	`dateAdd(Date date, Number interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<Date>`	`dateAdd(Date date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<Date>`	`dateAdd(Field<Date> date, Number interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<Date>`	`dateAdd(Field<Date> date, Field<? extends Number> interval)`	Add an interval to a date.
`static Field<Date>`	`dateAdd(Field<Date> date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<Integer>`	`dateDiff(Date date1, Date date2)`	Get the date difference in number of days.
`static Field<Integer>`	`dateDiff(Date date1, Field<Date> date2)`	Get the date difference in number of days.
`static Field<Integer>`	`dateDiff(Field<Date> date1, Date date2)`	Get the date difference in number of days.
`static Field<Integer>`	`dateDiff(Field<Date> date1, Field<Date> date2)`	Get the date difference in number of days.
`static Field<Date>`	`dateSub(Date date, Number interval)`	Subtract an interval from a date.
`static Field<Date>`	`dateSub(Date date, Number interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<Date>`	`dateSub(Date date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<Date>`	`dateSub(Field<Date> date, Number interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<Date>`	`dateSub(Field<Date> date, Field<? extends Number> interval)`	Subtract an interval from a date.
`static Field<Date>`	`dateSub(Field<Date> date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<Integer>`	`day(Temporal value)`	Get the day part of a date.
`static Field<Integer>`	`day(Date value)`	Get the day part of a date.
`static Field<Integer>`	`day(Field<?> field)`	Get the day part of a date.
`static Field<Integer>`	`dayOfWeek(Temporal value)`	Get the day of week part of a date.
`static Field<Integer>`	`dayOfWeek(Date value)`	Get the day of week part of a date.
`static Field<Integer>`	`dayOfWeek(Field<?> field)`	Get the day of week part of a date.
`static Field<Integer>`	`dayOfYear(Temporal value)`	Get the day of week part of a date.
`static Field<Integer>`	`dayOfYear(Date value)`	Get the day of week part of a date.
`static Field<Integer>`	`dayOfYear(Field<?> field)`	Get the day of week part of a date.
`static Field<Integer>`	`decade(Temporal value)`	Get the decade of a date.
`static Field<Integer>`	`decade(Date value)`	Get the decade of a date.
`static Field<Integer>`	`decade(Field<?> field)`	Get the decade of a date.
`static <T> Declaration<T>`	`declare(Variable<T> variable)`	Create a local variable declaration for use in procedural code.
`static Case`	`decode()`	Initialise a `Case` statement.
`static <Z,T> Field<Z>`	`decode(Field<T> value, Field<T> search, Field<Z> result)`	Gets the Oracle-style `DECODE(expression, search, result[, search , result]...`
`static <Z,T> Field<Z>`	`decode(Field<T> value, Field<T> search, Field<Z> result, Field<?>... more)`	Gets the Oracle-style `DECODE(expression, search, result[, search , result]...`
`static <Z,T> Field<Z>`	`decode(T value, T search, Z result)`	Gets the Oracle-style `DECODE(expression, search, result[, search , result]...`
`static <Z,T> Field<Z>`	`decode(T value, T search, Z result, Object... more)`	Gets the Oracle-style `DECODE(expression, search, result[, search , result]...`
`static Field<Object>`	`default_()`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static <T> Field<T>`	`default_(Class<T> type)`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static <T> Field<T>`	`default_(DataType<T> type)`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static <T> Field<T>`	`default_(Field<T> field)`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static Field<Object>`	`defaultValue()`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static <T> Field<T>`	`defaultValue(Class<T> type)`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static <T> Field<T>`	`defaultValue(DataType<T> type)`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static <T> Field<T>`	`defaultValue(Field<T> field)`	Create a `DEFAULT` keyword for use with `INSERT`, `UPDATE`, or `MERGE` statements.
`static Field<BigDecimal>`	`deg(Number value)`	Calculate degrees from radians from this field.
`static Field<BigDecimal>`	`deg(Field<? extends Number> field)`	Calculate degrees from radians from this field.
`static <R extends Record> DeleteWhereStep<R>`	`delete(Table<R> table)`	Create a new DSL delete statement.
`static <R extends Record> DeleteWhereStep<R>`	`deleteFrom(Table<R> table)`	Create a new DSL delete statement.
`static WindowOverStep<Integer>`	`denseRank()`	The `dense_rank() over ([analytic clause])` function.
`static OrderedAggregateFunction<Integer>`	`denseRank(Collection<? extends Field<?>> fields)`	The `dense_rank(expr) within group (order by [order clause])` ordered-set aggregate function.
`static OrderedAggregateFunction<Integer>`	`denseRank(Field<?>... fields)`	The `dense_rank(expr) within group (order by [order clause])` ordered-set aggregate function.
`static DropIndexOnStep`	`dropIndex(String index)`	Create a new DSL `DROP INDEX` statement.
`static DropIndexOnStep`	`dropIndex(Index index)`	Create a new DSL `DROP INDEX` statement.
`static DropIndexOnStep`	`dropIndex(Name index)`	Create a new DSL `DROP INDEX` statement.
`static DropIndexOnStep`	`dropIndexIfExists(String index)`	Create a new DSL `DROP INDEX IF EXISTS` statement.
`static DropIndexOnStep`	`dropIndexIfExists(Index index)`	Create a new DSL `DROP INDEX IF EXISTS` statement.
`static DropIndexOnStep`	`dropIndexIfExists(Name index)`	Create a new DSL `DROP INDEX IF EXISTS` statement.
`static DropSchemaStep`	`dropSchema(String schema)`	Create a new DSL `DROP SCHEMA` statement.
`static DropSchemaStep`	`dropSchema(Name schema)`	Create a new DSL `DROP SCHEMA` statement.
`static DropSchemaStep`	`dropSchema(Schema schema)`	Create a new DSL `DROP SCHEMA` statement.
`static DropSchemaStep`	`dropSchemaIfExists(String schema)`	Create a new DSL `DROP SCHEMA` statement.
`static DropSchemaStep`	`dropSchemaIfExists(Name schema)`	Create a new DSL `DROP SCHEMA` statement.
`static DropSchemaStep`	`dropSchemaIfExists(Schema schema)`	Create a new DSL `DROP SCHEMA` statement.
`static <T extends Number> DropSequenceFinalStep`	`dropSequence(String sequence)`	Create a new DSL `DROP SEQUENCE` statement.
`static <T extends Number> DropSequenceFinalStep`	`dropSequence(Name sequence)`	Create a new DSL `DROP SEQUENCE` statement.
`static <T extends Number> DropSequenceFinalStep`	`dropSequence(Sequence<?> sequence)`	Create a new DSL `DROP SEQUENCE` statement.
`static <T extends Number> DropSequenceFinalStep`	`dropSequenceIfExists(String sequence)`	Create a new DSL `DROP SEQUENCE IF EXISTS` statement.
`static <T extends Number> DropSequenceFinalStep`	`dropSequenceIfExists(Name sequence)`	Create a new DSL `DROP SEQUENCE IF EXISTS` statement.
`static <T extends Number> DropSequenceFinalStep`	`dropSequenceIfExists(Sequence<?> sequence)`	Create a new DSL `DROP SEQUENCE IF EXISTS` statement.
`static DropTableStep`	`dropTable(String table)`	Create a new DSL `DROP TABLE` statement.
`static DropTableStep`	`dropTable(Name table)`	Create a new DSL `DROP TABLE` statement.
`static DropTableStep`	`dropTable(Table<?> table)`	Create a new DSL `DROP TABLE` statement.
`static DropTableStep`	`dropTableIfExists(String table)`	Create a new DSL `DROP TABLE IF EXISTS` statement.
`static DropTableStep`	`dropTableIfExists(Name table)`	Create a new DSL `DROP TABLE IF EXISTS` statement.
`static DropTableStep`	`dropTableIfExists(Table<?> table)`	Create a new DSL `DROP TABLE IF EXISTS` statement.
`static DropTableStep`	`dropTemporaryTable(String table)`	Create a new DSL `DROP TEMPORARY TABLE` statement.
`static DropTableStep`	`dropTemporaryTable(Name table)`	Create a new DSL `DROP TEMPORARY TABLE` statement.
`static DropTableStep`	`dropTemporaryTable(Table<?> table)`	Create a new DSL `DROP TEMPORARY TABLE` statement.
`static DropTypeStep`	`dropType(String type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropType(String... type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropType(Collection<?> type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropType(Name type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropType(Name... type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropTypeIfExists(String type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropTypeIfExists(String... type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropTypeIfExists(Collection<?> type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropTypeIfExists(Name type)`	Create a new DSL `DROP TYPE` statement.
`static DropTypeStep`	`dropTypeIfExists(Name... type)`	Create a new DSL `DROP TYPE` statement.
`static DropViewFinalStep`	`dropView(String view)`	Create a new DSL `DROP VIEW` statement.
`static DropViewFinalStep`	`dropView(Name view)`	Create a new DSL `DROP VIEW` statement.
`static DropViewFinalStep`	`dropView(Table<?> view)`	Create a new DSL `DROP VIEW` statement.
`static DropViewFinalStep`	`dropViewIfExists(String view)`	Create a new DSL `DROP VIEW IF EXISTS` statement.
`static DropViewFinalStep`	`dropViewIfExists(Name view)`	Create a new DSL `DROP VIEW IF EXISTS` statement.
`static DropViewFinalStep`	`dropViewIfExists(Table<?> view)`	Create a new DSL `DROP VIEW IF EXISTS` statement.
`static Table<Record>`	`dual()`	The `DUAL` table to be used for syntactic completeness.
`static Field<BigDecimal>`	`e()`	The `E` literal (Euler number).
`static Field<Integer>`	`epoch(Temporal value)`	Get the epoch of a date.
`static Field<Integer>`	`epoch(Date value)`	Get the epoch of a date.
`static Field<Integer>`	`epoch(Field<?> field)`	Get the epoch of a date.
`static String`	`escape(String value, char escape)`	Convenience method for `replace(Field, String, String)` to escape data for use with `Field.like(Field, char)`.
`static Field<String>`	`escape(Field<String> field, char escape)`	Convenience method for `replace(Field, String, String)` to escape data for use with `Field.like(Field, char)`.
`static AggregateFunction<Boolean>`	`every(Condition condition)`	Get the every value over a condition: every(condition).
`static AggregateFunction<Boolean>`	`every(Field<Boolean> field)`	Get the every value over a field: every(field).
`static Statement`	`execute(String sql)`	Execute a statement dynamically from within procedural code.
`static Statement`	`execute(Field<String> sql)`	Execute a statement dynamically from within procedural code.
`static Condition`	`exists(Select<?> query)`	Create an exists condition.
`static ExitWhenStep`	`exit()`	Create an `EXIT` statement for use in procedural code.
`static ExitWhenStep`	`exit(Label label)`	Create an `EXIT` statement for use in procedural code.
`static Statement`	`exitWhen(Condition condition)`	Create an `EXIT` statement for use in procedural code.
`static Field<BigDecimal>`	`exp(Number value)`	Get the exp(field) function, taking this field as the power of e.
`static Field<BigDecimal>`	`exp(Field<? extends Number> field)`	Get the exp(field) function, taking this field as the power of e.
`static Field<Integer>`	`extract(Temporal value, DatePart datePart)`	Get the extract(field, datePart) function.
`static Field<Integer>`	`extract(Date value, DatePart datePart)`	Get the extract(field, datePart) function.
`static Field<Integer>`	`extract(Field<?> field, DatePart datePart)`	Get the extract(field, datePart) function.
`static False`	`falseCondition()`	Return a `Condition` that will always evaluate to false.
`static Field<Object>`	`field(String sql)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(String sql, Class<T> type)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(String sql, Class<T> type, Object... bindings)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(String sql, Class<T> type, QueryPart... parts)`	A custom SQL clause that can render arbitrary SQL elements.
`static Field<Object>`	`field(String sql, Object... bindings)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(String sql, DataType<T> type)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(String sql, DataType<T> type, Object... bindings)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(String sql, DataType<T> type, QueryPart... parts)`	Create a "plain SQL" field.
`static Field<Object>`	`field(String sql, QueryPart... parts)`	A custom SQL clause that can render arbitrary SQL elements.
`static Field<Boolean>`	`field(Condition condition)`	Transform a condition into a boolean field.
`static Field<Object>`	`field(Name name)`	Create a qualified field, given its (qualified) field name.
`static <T> Field<T>`	`field(Name name, Class<T> type)`	Create a qualified field, given its (qualified) field name.
`static <T> Field<T>`	`field(Name name, DataType<T> type)`	Create a qualified field, given its (qualified) field name.
`static <T> Field<T>`	`field(Name name, DataType<T> type, Comment comment)`	Create a qualified field, given its (qualified) field name.
`static <T> Field<T>`	`field(Select<? extends Record1<T>> select)`	Transform a subquery into a correlated subquery.
`static <T> Field<T>`	`field(SelectField<T> field)`	Wrap a `SelectField` in a general-purpose `Field`
`static Field<Object>`	`field(SQL sql)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(SQL sql, Class<T> type)`	Create a "plain SQL" field.
`static <T> Field<T>`	`field(SQL sql, DataType<T> type)`	Create a "plain SQL" field.
`static <T> Field<T>`	`fieldByName(Class<T> type, String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `field(Name, Class)` instead
`static Field<Object>`	`fieldByName(String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `field(Name)` instead
`static <T> Field<T>`	`fieldByName(DataType<T> type, String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `field(Name, DataType)` instead
`static <T> WindowIgnoreNullsStep<T>`	`firstValue(Field<T> field)`	The `first_value(field) over ([analytic clause])` function.
`static <T extends Number> Field<T>`	`floor(Field<T> field)`	Get the largest integer value not greater than [this].
`static <T extends Number> Field<T>`	`floor(T value)`	Get the largest integer value not greater than [this].
`static <T> ForInStep<T>`	`for_(Variable<T> index)`	Create a `FOR` loop for use in procedural code.
`static ConstraintForeignKeyReferencesStep1<?>`	`foreignKey(String field1)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStepN`	`foreignKey(String... fields)`	Add a `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep2<?,?>`	`foreignKey(String field1, String field2)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep3<?,?,?>`	`foreignKey(String field1, String field2, String field3)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep4<?,?,?,?>`	`foreignKey(String field1, String field2, String field3, String field4)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep5<?,?,?,?,?>`	`foreignKey(String field1, String field2, String field3, String field4, String field5)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?>`	`foreignKey(String field1, String field2, String field3, String field4, String field5, String field6)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStepN`	`foreignKey(Field<?>... fields)`	Add a `FOREIGN KEY` clause to the `CONSTRAINT`.
`static <T1> ConstraintForeignKeyReferencesStep1<T1>`	`foreignKey(Field<T1> field1)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static <T1,T2> ConstraintForeignKeyReferencesStep2<T1,T2>`	`foreignKey(Field<T1> field1, Field<T2> field2)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static <T1,T2,T3> ConstraintForeignKeyReferencesStep3<T1,T2,T3>`	`foreignKey(Field<T1> field1, Field<T2> field2, Field<T3> field3)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static <T1,T2,T3,T4> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> 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 the `CONSTRAINT`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> 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 the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep1<?>`	`foreignKey(Name field1)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStepN`	`foreignKey(Name... fields)`	Add a `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep2<?,?>`	`foreignKey(Name field1, Name field2)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep3<?,?,?>`	`foreignKey(Name field1, Name field2, Name field3)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep4<?,?,?,?>`	`foreignKey(Name field1, Name field2, Name field3, Name field4)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep5<?,?,?,?,?>`	`foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?>`	`foreignKey(Name field1, Name field2, Name field3, Name field4, Name field5, Name field6)`	Add an unnamed (system named) `FOREIGN KEY` clause to the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static 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 the `CONSTRAINT`.
`static <T> 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> 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> 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> 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 Table<Record1<Integer>>`	`generateSeries(int from, int to)`	A table function generating a series of values from `from` to `to` (inclusive).
`static Table<Record1<Integer>>`	`generateSeries(int from, int to, int step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(int from, int to, Field<Integer> step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(int from, Field<Integer> to)`	A table function generating a series of values from `from` to `to` (inclusive).
`static Table<Record1<Integer>>`	`generateSeries(int from, Field<Integer> to, int step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(int from, Field<Integer> to, Field<Integer> step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(Field<Integer> from, int to)`	A table function generating a series of values from `from` to `to` (inclusive).
`static Table<Record1<Integer>>`	`generateSeries(Field<Integer> from, int to, int step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(Field<Integer> from, int to, Field<Integer> step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(Field<Integer> from, Field<Integer> to)`	A table function generating a series of values from `from` to `to` (inclusive).
`static Table<Record1<Integer>>`	`generateSeries(Field<Integer> from, Field<Integer> to, int step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static Table<Record1<Integer>>`	`generateSeries(Field<Integer> from, Field<Integer> to, Field<Integer> step)`	A table function generating a series of values from `from` to `to` (inclusive), increasing values by `step`.
`static <T> 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 Statement`	`goto_(Label label)`	Create an `GOTO` statement for use in procedural code.
`static GrantOnStep`	`grant(Collection<? extends Privilege> privileges)`	Grant privileges on table to user or role.
`static GrantOnStep`	`grant(Privilege privilege)`	Grant a privilege on table to user or role.
`static GrantOnStep`	`grant(Privilege... privileges)`	Grant privileges on table to user or role.
`static <T> Field<T>`	`greatest(Field<T> field, Field<?>... others)`	Find the greatest among all values.
`static <T> Field<T>`	`greatest(T value, T... values)`	Find the greatest among all values.
`static GroupConcatOrderByStep`	`groupConcat(Field<?> field)`	Get the aggregated concatenation for a field.
`static AggregateFunction<String>`	`groupConcat(Field<?> field, String separator)`	Deprecated. - [#7956] - 3.12.0 - Use `groupConcat(Field)` and `GroupConcatSeparatorStep.separator(String)` instead.
`static GroupConcatOrderByStep`	`groupConcatDistinct(Field<?> field)`	Get the aggregated concatenation for a field.
`static Field<Integer>`	`groupId()`	Create a `GROUP_ID()` aggregation function to be used along with `CUBE`, `ROLLUP`, and `GROUPING SETS` groupings.
`static Field<Integer>`	`grouping(Field<?> field)`	Create a GROUPING(field) aggregation field to be used along with `CUBE`, `ROLLUP`, and `GROUPING SETS` groupings.
`static Field<Integer>`	`groupingId(Field<?>... fields)`	Create a GROUPING_ID(field1, field2, .., fieldn) aggregation field to be used along with `CUBE`, `ROLLUP`, and `GROUPING SETS` groupings.
`static GroupField`	`groupingSets(Collection<? extends Field<?>>... fieldSets)`	Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna, fieldnb)) grouping field.
`static GroupField`	`groupingSets(Field<?>... fields)`	Create a GROUPING SETS(field1, field2, .., fieldn) grouping field where each grouping set only consists of a single field.
`static GroupField`	`groupingSets(Field<?>[]... fieldSets)`	Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna, fieldnb)) grouping field.
`static WindowSpecificationRowsAndStep`	`groupsBetweenCurrentRow()`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationRowsAndStep`	`groupsBetweenFollowing(int number)`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationRowsAndStep`	`groupsBetweenPreceding(int number)`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationRowsAndStep`	`groupsBetweenUnboundedFollowing()`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationRowsAndStep`	`groupsBetweenUnboundedPreceding()`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationExcludeStep`	`groupsCurrentRow()`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationExcludeStep`	`groupsFollowing(int number)`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationExcludeStep`	`groupsPreceding(int number)`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationExcludeStep`	`groupsUnboundedFollowing()`	Create a `WindowSpecification` with a `GROUPS` clause.
`static WindowSpecificationExcludeStep`	`groupsUnboundedPreceding()`	Create a `WindowSpecification` with a `GROUPS` clause.
`static Field<Integer>`	`hour(Temporal value)`	Get the hour part of a date.
`static Field<Integer>`	`hour(Date value)`	Get the hour part of a date.
`static Field<Integer>`	`hour(Field<?> field)`	Get the hour part of a date.
`static IfThenStep`	`if_(Condition condition)`	Create an `IF` statement for use in procedural code.
`static <T> Field<T>`	`ifnull(Field<T> value, Field<T> defaultValue)`	The `IFNULL()` function, a synonym of `NVL()`.
`static <T> Field<T>`	`ifnull(Field<T> value, T defaultValue)`	The `IFNULL()` function, a synonym of `NVL()`.
`static <T> Field<T>`	`ifnull(T value, Field<T> defaultValue)`	The `IFNULL()` function, a synonym of `NVL()`.
`static <T> Field<T>`	`ifnull(T value, T defaultValue)`	The `IFNULL()` function, a synonym of `NVL()`.
`static <T> Field<T>`	`iif(Condition condition, Field<T> ifTrue, Field<T> ifFalse)`	Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.
`static <T> Field<T>`	`iif(Condition condition, Field<T> ifTrue, T ifFalse)`	Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.
`static <T> Field<T>`	`iif(Condition condition, T ifTrue, Field<T> ifFalse)`	Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.
`static <T> Field<T>`	`iif(Condition condition, T ifTrue, T ifFalse)`	Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.
`static Index`	`index(Name name)`	Create a qualified index reference by name.
`static Param<Boolean>`	`inline(boolean value)`	Create a bind value that is always inlined.
`static Param<Byte>`	`inline(byte value)`	Create a bind value that is always inlined.
`static Param<byte[]>`	`inline(byte[] value)`	Create a bind value that is always inlined.
`static Param<String>`	`inline(char character)`	Create a bind value, that is always inlined.
`static Param<Double>`	`inline(double value)`	Create a bind value that is always inlined.
`static Param<Float>`	`inline(float value)`	Create a bind value that is always inlined.
`static Param<Integer>`	`inline(int value)`	Create a bind value that is always inlined.
`static Param<Long>`	`inline(long value)`	Create a bind value that is always inlined.
`static Param<Short>`	`inline(short value)`	Create a bind value that is always inlined.
`static Param<Boolean>`	`inline(Boolean value)`	Create a bind value that is always inlined.
`static Param<Byte>`	`inline(Byte value)`	Create a bind value that is always inlined.
`static Param<String>`	`inline(Character character)`	Create a bind value, that is always inlined.
`static Param<String>`	`inline(CharSequence character)`	Create a bind value, that is always inlined.
`static Param<Double>`	`inline(Double value)`	Create a bind value that is always inlined.
`static Param<Float>`	`inline(Float value)`	Create a bind value that is always inlined.
`static Param<Integer>`	`inline(Integer value)`	Create a bind value that is always inlined.
`static Param<Long>`	`inline(Long value)`	Create a bind value that is always inlined.
`static <T> Param<T>`	`inline(Object value, Class<T> type)`	Create a bind value, that is always inlined.
`static <T> Param<T>`	`inline(Object value, DataType<T> type)`	Create a bind value, that is always inlined.
`static <T> Param<T>`	`inline(Object value, Field<T> field)`	Create a bind value, that is always inlined.
`static Param<Short>`	`inline(Short value)`	Create a bind value that is always inlined.
`static Param<String>`	`inline(String value)`	Create a bind value that is always inlined.
`static Param<BigDecimal>`	`inline(BigDecimal value)`	Create a bind value that is always inlined.
`static Param<BigInteger>`	`inline(BigInteger value)`	Create a bind value that is always inlined.
`static Param<Date>`	`inline(Date value)`	Create a bind value that is always inlined.
`static Param<Time>`	`inline(Time value)`	Create a bind value that is always inlined.
`static Param<Timestamp>`	`inline(Timestamp value)`	Create a bind value that is always inlined.
`static Param<Instant>`	`inline(Instant value)`	Create a bind value that is always inlined.
`static Param<LocalDate>`	`inline(LocalDate value)`	Create a bind value that is always inlined.
`static Param<LocalDateTime>`	`inline(LocalDateTime value)`	Create a bind value that is always inlined.
`static Param<LocalTime>`	`inline(LocalTime value)`	Create a bind value that is always inlined.
`static Param<OffsetDateTime>`	`inline(OffsetDateTime value)`	Create a bind value that is always inlined.
`static Param<OffsetTime>`	`inline(OffsetTime value)`	Create a bind value that is always inlined.
`static Param<UUID>`	`inline(UUID value)`	Create a bind value that is always inlined.
`static Param<UByte>`	`inline(UByte value)`	Create a bind value that is always inlined.
`static Param<UInteger>`	`inline(UInteger value)`	Create a bind value that is always inlined.
`static Param<ULong>`	`inline(ULong value)`	Create a bind value that is always inlined.
`static Param<UShort>`	`inline(UShort value)`	Create a bind value that is always inlined.
`static <T> Param<T>`	`inline(T value)`	Create a bind value, that is always inlined.
`static <R extends Record> InsertSetStep<R>`	`insertInto(Table<R> into)`	Create a new DSL insert statement.
`static <R extends Record> InsertValuesStepN<R>`	`insertInto(Table<R> into, Collection<? extends Field<?>> fields)`	Create a new DSL insert statement.
`static <R extends Record> InsertValuesStepN<R>`	`insertInto(Table<R> into, Field<?>... fields)`	Create a new DSL insert statement.
`static <R extends Record,T1> InsertValuesStep1<R,T1>`	`insertInto(Table<R> into, Field<T1> field1)`	Create a new DSL insert statement.
`static <R extends Record,T1,T2> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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 Field<Instant>`	`instant(String value)`	Convert a string value to a `TIMESTAMP WITH TIME ZONE`.
`static Field<Instant>`	`instant(Instant value)`	Convert a temporal value to a `TIMESTAMP WITH TIME ZONE`.
`static Field<Instant>`	`instant(Field<Instant> field)`	Convert a temporal value to a `TIMESTAMP WITH TIME ZONE`.
`static <T> Field<T>`	`isnull(Field<T> value, Field<T> defaultValue)`	Gets the SQL Server-style ISNULL(value, defaultValue) function.
`static <T> Field<T>`	`isnull(Field<T> value, T defaultValue)`	Gets the SQL Server-style ISNULL(value, defaultValue) function.
`static <T> Field<T>`	`isnull(T value, Field<T> defaultValue)`	Gets the SQL Server-style ISNULL(value, defaultValue) function.
`static <T> Field<T>`	`isnull(T value, T defaultValue)`	Gets the SQL Server-style ISNULL(value, defaultValue) function.
`static Field<Integer>`	`isoDayOfWeek(Temporal value)`	Get the ISO day of week part of a date.
`static Field<Integer>`	`isoDayOfWeek(Date value)`	Get the ISO day of week part of a date.
`static Field<Integer>`	`isoDayOfWeek(Field<?> field)`	Get the ISO day of week part of a date.
`static Field<JSON>`	`jsonArray(Collection<? extends Field<?>> fields)`	The JSON array constructor.
`static Field<JSON>`	`jsonArray(Field<?>... fields)`	The JSON array constructor.
`static Field<JSONB>`	`jsonbArray(Collection<? extends Field<?>> fields)`	The JSONB array constructor.
`static Field<JSONB>`	`jsonbArray(Field<?>... fields)`	The JSONB array constructor.
`static Field<JSONB>`	`jsonbObject(Collection<? extends JSONEntry<?>> entries)`	The JSONB object constructor.
`static Field<JSONB>`	`jsonbObject(JSONEntry<?>... entries)`	The JSONB object constructor.
`static <T> JSONEntry<T>`	`jsonEntry(Field<String> key, Field<T> value)`	A constructor for JSON entries to be used with `jsonObject(JSONEntry...)`.
`static Field<JSON>`	`jsonObject(Collection<? extends JSONEntry<?>> entries)`	The JSON object constructor.
`static Field<JSON>`	`jsonObject(Field<String> key, Field<?> value)`	The JSON object constructor.
`static Field<JSON>`	`jsonObject(JSONEntry<?>... entries)`	The JSON object constructor.
`static Keyword`	`keyword(String keyword)`	Create a SQL keyword.
`static Label`	`label(String label)`	Create a label reference for use in procedural code.
`static Label`	`label(Name label)`	Create a label reference for use in procedural code.
`static <T> WindowIgnoreNullsStep<T>`	`lag(Field<T> field)`	The `lag(field) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lag(Field<T> field, int offset)`	The `lag(field, offset) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lag(Field<T> field, int offset, Field<T> defaultValue)`	The `lag(field, offset, defaultValue) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lag(Field<T> field, int offset, T defaultValue)`	The `lag(field, offset, defaultValue) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lastValue(Field<T> field)`	The `last_value(field) over ([analytic clause])` function.
`static <R extends Record> Table<R>`	`lateral(TableLike<R> table)`	Create a `LATERAL` joined table.
`static <T> WindowIgnoreNullsStep<T>`	`lead(Field<T> field)`	The `lead(field) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lead(Field<T> field, int offset)`	The `lead(field, offset) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lead(Field<T> field, int offset, Field<T> defaultValue)`	The `lead(field, offset, defaultValue) over ([analytic clause])` function.
`static <T> WindowIgnoreNullsStep<T>`	`lead(Field<T> field, int offset, T defaultValue)`	The `lead(field, offset, defaultValue) over ([analytic clause])` function.
`static <T> Field<T>`	`least(Field<T> field, Field<?>... others)`	Find the least among all values.
`static <T> Field<T>`	`least(T value, T... values)`	Find the least among all values.
`static Field<String>`	`left(String field, int length)`	Get the left outermost characters from a string.
`static Field<String>`	`left(String field, Field<? extends Number> length)`	Get the left outermost characters from a string.
`static Field<String>`	`left(Field<String> field, int length)`	Get the left outermost characters from a string.
`static Field<String>`	`left(Field<String> field, Field<? extends Number> length)`	Get the left outermost characters from a string.
`static Field<Integer>`	`length(String value)`	Get the length of a `VARCHAR` type.
`static Field<Integer>`	`length(Field<String> field)`	Get the length of a `VARCHAR` type.
`static Field<Integer>`	`level()`	Retrieve the Oracle-specific `LEVEL` pseudo-field (to be used along with `CONNECT BY` clauses).
`static Link`	`link(String name)`	Create a database link reference.
`static Link`	`link(String name, Schema schema)`	Create a database link reference.
`static Link`	`link(Name name)`	Create a database link reference.
`static QueryPart`	`list(Collection<? extends QueryPart> parts)`	Compose a list of `QueryParts` into a new `QueryPart`, with individual parts being comma-separated.
`static QueryPart`	`list(QueryPart... parts)`	Compose a list of `QueryParts` into a new `QueryPart`, with individual parts being comma-separated.
`static OrderedAggregateFunction<String>`	`listAgg(Field<?> field)`	Get the aggregated concatenation for a field.
`static OrderedAggregateFunction<String>`	`listAgg(Field<?> field, String separator)`	Get the aggregated concatenation for a field.
`static Field<BigDecimal>`	`ln(Number value)`	Get the ln(field) function, taking the natural logarithm of this field.
`static Field<BigDecimal>`	`ln(Field<? extends Number> field)`	Get the ln(field) function, taking the natural logarithm of this field.
`static Field<LocalDate>`	`localDate(String value)`	Convert a string value to a `DATE`.
`static Field<LocalDate>`	`localDate(LocalDate value)`	Convert a temporal value to a `DATE`.
`static Field<LocalDate>`	`localDate(Field<LocalDate> field)`	Convert a temporal value to a `DATE`.
`static Field<LocalDate>`	`localDateAdd(LocalDate date, Number interval)`	Add an interval to a date.
`static Field<LocalDate>`	`localDateAdd(LocalDate date, Number interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<LocalDate>`	`localDateAdd(LocalDate date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<LocalDate>`	`localDateAdd(Field<LocalDate> date, Number interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<LocalDate>`	`localDateAdd(Field<LocalDate> date, Field<? extends Number> interval)`	Add an interval to a date.
`static Field<LocalDate>`	`localDateAdd(Field<LocalDate> date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a date, given a date part.
`static Field<Integer>`	`localDateDiff(LocalDate date1, LocalDate date2)`	Get the date difference in number of days.
`static Field<Integer>`	`localDateDiff(LocalDate date1, Field<LocalDate> date2)`	Get the date difference in number of days.
`static Field<Integer>`	`localDateDiff(Field<LocalDate> date1, LocalDate date2)`	Get the date difference in number of days.
`static Field<Integer>`	`localDateDiff(Field<LocalDate> date1, Field<LocalDate> date2)`	Get the date difference in number of days.
`static Field<LocalDate>`	`localDateSub(LocalDate date, Number interval)`	Subtract an interval from a date.
`static Field<LocalDate>`	`localDateSub(LocalDate date, Number interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<LocalDate>`	`localDateSub(LocalDate date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<LocalDate>`	`localDateSub(Field<LocalDate> date, Number interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<LocalDate>`	`localDateSub(Field<LocalDate> date, Field<? extends Number> interval)`	Subtract an interval from a date.
`static Field<LocalDate>`	`localDateSub(Field<LocalDate> date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a date, given a date part.
`static Field<LocalDateTime>`	`localDateTime(String value)`	Convert a string value to a `TIMESTAMP`.
`static Field<LocalDateTime>`	`localDateTime(LocalDateTime value)`	Convert a temporal value to a `TIMESTAMP`.
`static Field<LocalDateTime>`	`localDateTime(Field<LocalDateTime> field)`	Convert a temporal value to a `TIMESTAMP`.
`static Field<LocalDateTime>`	`localDateTimeAdd(LocalDateTime timestamp, Number interval)`	Add an interval to a timestamp.
`static Field<LocalDateTime>`	`localDateTimeAdd(LocalDateTime date, Number interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<LocalDateTime>`	`localDateTimeAdd(LocalDateTime date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<LocalDateTime>`	`localDateTimeAdd(Field<LocalDateTime> date, Number interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<LocalDateTime>`	`localDateTimeAdd(Field<LocalDateTime> timestamp, Field<? extends Number> interval)`	Add an interval to a timestamp.
`static Field<LocalDateTime>`	`localDateTimeAdd(Field<LocalDateTime> date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<DayToSecond>`	`localDateTimeDiff(LocalDateTime timestamp1, LocalDateTime timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`localDateTimeDiff(LocalDateTime timestamp1, Field<LocalDateTime> timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`localDateTimeDiff(Field<LocalDateTime> timestamp1, LocalDateTime timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`localDateTimeDiff(Field<LocalDateTime> timestamp1, Field<LocalDateTime> timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<LocalDateTime>`	`localDateTimeSub(LocalDateTime timestamp, Number interval)`	Subtract an interval from a timestamp.
`static Field<LocalDateTime>`	`localDateTimeSub(LocalDateTime date, Number interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<LocalDateTime>`	`localDateTimeSub(LocalDateTime date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<LocalDateTime>`	`localDateTimeSub(Field<LocalDateTime> date, Number interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<LocalDateTime>`	`localDateTimeSub(Field<LocalDateTime> timestamp, Field<? extends Number> interval)`	Subtract an interval from a timestamp.
`static Field<LocalDateTime>`	`localDateTimeSub(Field<LocalDateTime> date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<LocalTime>`	`localTime(String value)`	Convert a string value to a `TIME`.
`static Field<LocalTime>`	`localTime(LocalTime value)`	Convert a temporal value to a `TIME`.
`static Field<LocalTime>`	`localTime(Field<LocalTime> field)`	Convert a temporal value to a `TIME`.
`static Field<BigDecimal>`	`log(Number value, int base)`	Get the log(field, base) function.
`static Field<BigDecimal>`	`log(Field<? extends Number> field, int base)`	Get the log(field, base) function.
`static Field<BigDecimal>`	`log(Field<? extends Number> field, Field<? extends Number> base)`	Get the log(field, base) function.
`static Statement`	`loop(Collection<? extends Statement> statements)`	Create a `LOOP` for use in procedural code.
`static Statement`	`loop(Statement... statements)`	Create a `LOOP` for use in procedural code.
`static Field<String>`	`lower(String value)`	Get the lower(field) function.
`static Field<String>`	`lower(Field<String> field)`	Get the lower(field) function.
`static Field<String>`	`lpad(Field<String> field, int length)`	Get the lpad(field, length) function.
`static Field<String>`	`lpad(Field<String> field, int length, char character)`	Get the lpad(field, length, character) function.
`static Field<String>`	`lpad(Field<String> field, int length, String character)`	Get the lpad(field, length, character) function.
`static Field<String>`	`lpad(Field<String> field, Field<? extends Number> length)`	Get the lpad(field, length) function.
`static Field<String>`	`lpad(Field<String> field, Field<? extends Number> length, Field<String> character)`	Get the lpad(field, length, character) function.
`static Field<String>`	`ltrim(String value)`	Get the ltrim(field) function.
`static Field<String>`	`ltrim(String value, String characters)`	Get the `ltrim(field, characters)` or `trim(leading characters from field)` function.
`static Field<String>`	`ltrim(Field<String> field)`	Get the ltrim(field) function.
`static Field<String>`	`ltrim(Field<String> field, Field<String> characters)`	Get the `ltrim(field, characters)` or `trim(leading characters from field)` function.
`static <T> AggregateFunction<T>`	`max(Field<T> field)`	Get the max value over a field: max(field).
`static <T> AggregateFunction<T>`	`maxDistinct(Field<T> field)`	Get the max value over a field: max(distinct field).
`static Field<String>`	`md5(String string)`	Get the MySQL-specific `MD5()` function.
`static Field<String>`	`md5(Field<String> string)`	Get the MySQL-specific `MD5()` function.
`static AggregateFunction<BigDecimal>`	`median(Field<? extends Number> field)`	Get the median over a numeric field: median(field).
`static <R extends Record> MergeUsingStep<R>`	`mergeInto(Table<R> table)`	Create a new DSL SQL standard MERGE statement.
`static <R extends Record> MergeKeyStepN<R>`	`mergeInto(Table<R> table, Collection<? extends Field<?>> fields)`	Create a new DSL merge statement (H2-specific syntax).
`static <R extends Record> MergeKeyStepN<R>`	`mergeInto(Table<R> table, Field<?>... fields)`	Create a new DSL merge statement (H2-specific syntax).
`static <R extends Record,T1> MergeKeyStep1<R,T1>`	`mergeInto(Table<R> table, Field<T1> field1)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2> MergeKeyStep2<R,T1,T2>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3> MergeKeyStep3<R,T1,T2,T3>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4> MergeKeyStep4<R,T1,T2,T3,T4>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`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> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`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> 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)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`static Field<Integer>`	`microsecond(Temporal value)`	Get the microsecond part of a date.
`static Field<Integer>`	`microsecond(Date value)`	Get the microsecond part of a date.
`static Field<Integer>`	`microsecond(Field<?> field)`	Get the microsecond part of a date.
`static Field<String>`	`mid(Field<String> field, int startingPosition, int length)`	Get the mid(field, startingPosition, length) function.
`static Field<String>`	`mid(Field<String> field, Field<? extends Number> startingPosition, Field<? extends Number> length)`	Get the mid(field, startingPosition, length) function.
`static Field<Integer>`	`millennium(Temporal value)`	Get the millennium of a date.
`static Field<Integer>`	`millennium(Date value)`	Get the millennium of a date.
`static Field<Integer>`	`millennium(Field<?> field)`	Get the millennium of a date.
`static Field<Integer>`	`millisecond(Temporal value)`	Get the millisecond part of a date.
`static Field<Integer>`	`millisecond(Date value)`	Get the millisecond part of a date.
`static Field<Integer>`	`millisecond(Field<?> field)`	Get the millisecond part of a date.
`static <T> AggregateFunction<T>`	`min(Field<T> field)`	Get the min value over a field: min(field).
`static <T> AggregateFunction<T>`	`minDistinct(Field<T> field)`	Get the min value over a field: min(distinct field).
`static <T extends Number> Field<T>`	`minus(Field<T> field)`	Negate a field to get its negative value.
`static Field<Integer>`	`minute(Temporal value)`	Get the minute part of a date.
`static Field<Integer>`	`minute(Date value)`	Get the minute part of a date.
`static Field<Integer>`	`minute(Field<?> field)`	Get the minute part of a date.
`static OrderedAggregateFunctionOfDeferredType`	`mode()`	The `mode() within group (oder by [order clause])` ordered aggregate function.
`static <T> AggregateFunction<T>`	`mode(Field<T> field)`	The `mode(field)` aggregate function.
`static Field<Integer>`	`month(Temporal value)`	Get the month part of a date.
`static Field<Integer>`	`month(Date value)`	Get the month part of a date.
`static Field<Integer>`	`month(Field<?> field)`	Get the month part of a date.
`static Name`	`name(String unqualifiedName)`	Create a new SQL identifier using an unqualified name.
`static Name`	`name(String... qualifiedName)`	Create a new SQL identifier using a qualified name.
`static Name`	`name(Collection<String> qualifiedName)`	Create a new SQL identifier using a qualified name.
`static Name`	`name(Name... nameParts)`	Create a new SQL identifier using a qualified name.
`static <T extends Number> Field<T>`	`neg(Field<T> field)`	Negate a field to get its negative value.
`static Condition`	`noCondition()`	Return a `Condition` that behaves like no condition being present.
`static Field<Boolean>`	`not(Boolean value)`	Deprecated. - 3.8.0 - [#4763] - Use `not(Condition)` instead.
`static Condition`	`not(Condition condition)`	Invert a condition.
`static Field<Boolean>`	`not(Field<Boolean> field)`	Invert a boolean value.
`static Condition`	`notExists(Select<?> query)`	Create a not exists condition.
`static Condition`	`notUnique(Select<?> query)`	Create a not unique condition.
`static Field<Timestamp>`	`now()`	Synonym for `currentTimestamp()`.
`static Field<Timestamp>`	`now(Field<Integer> precision)`	Synonym for `currentTimestamp(Field)`.
`static <T> WindowFromFirstLastStep<T>`	`nthValue(Field<T> field, int nth)`	The `nth_value(field) over ([analytic clause])` function.
`static <T> WindowFromFirstLastStep<T>`	`nthValue(Field<T> field, Field<Integer> nth)`	The `nth_value(field) over ([analytic clause])` function.
`static WindowOverStep<Integer>`	`ntile(int number)`	The `ntile([number]) over ([analytic clause])` function.
`static <T> Field<T>`	`nullif(Field<T> value, Field<T> other)`	Gets the Oracle-style NULLIF(value, other) function.
`static <T> Field<T>`	`nullif(Field<T> value, T other)`	Gets the Oracle-style NULLIF(value, other) function.
`static <T> Field<T>`	`nullif(T value, Field<T> other)`	Gets the Oracle-style NULLIF(value, other) function.
`static <T> 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.
`static <T> Field<T>`	`nvl(Field<T> value, Field<T> defaultValue)`	Gets the Oracle-style NVL(value, defaultValue) function.
`static <T> Field<T>`	`nvl(Field<T> value, T defaultValue)`	Gets the Oracle-style NVL(value, defaultValue) function.
`static <T> Field<T>`	`nvl(T value, Field<T> defaultValue)`	Gets the Oracle-style NVL(value, defaultValue) function.
`static <T> Field<T>`	`nvl(T value, T defaultValue)`	Gets the Oracle-style NVL(value, defaultValue) function.
`static <Z> Field<Z>`	`nvl2(Field<?> value, Field<Z> valueIfNotNull, Field<Z> valueIfNull)`	Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.
`static <Z> Field<Z>`	`nvl2(Field<?> value, Field<Z> valueIfNotNull, Z valueIfNull)`	Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.
`static <Z> Field<Z>`	`nvl2(Field<?> value, Z valueIfNotNull, Field<Z> valueIfNull)`	Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.
`static <Z> Field<Z>`	`nvl2(Field<?> value, Z valueIfNotNull, Z valueIfNull)`	Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.
`static Field<Integer>`	`octetLength(String value)`	Get the octet_length(field) function.
`static Field<Integer>`	`octetLength(Field<String> field)`	Get the octet_length(field) function.
`static Field<OffsetDateTime>`	`offsetDateTime(String value)`	Convert a string value to a `TIMESTAMP WITH TIME ZONE`.
`static Field<OffsetDateTime>`	`offsetDateTime(OffsetDateTime value)`	Convert a temporal value to a `TIMESTAMP WITH TIME ZONE`.
`static Field<OffsetDateTime>`	`offsetDateTime(Field<OffsetDateTime> field)`	Convert a temporal value to a `TIMESTAMP WITH TIME ZONE`.
`static Field<OffsetTime>`	`offsetTime(String value)`	Convert a string value to a `TIME WITH TIME ZONE`.
`static Field<OffsetTime>`	`offsetTime(OffsetTime value)`	Convert a temporal value to a `TIME WITH TIME ZONE`.
`static Field<OffsetTime>`	`offsetTime(Field<OffsetTime> field)`	Convert a temporal value to a `TIME WITH TIME ZONE`.
`static Param<Integer>`	`one()`	A `1` literal.
`static Condition`	`or(Collection<? extends Condition> conditions)`	Return a `Condition` that connects all argument `conditions` with `Operator.OR`.
`static Condition`	`or(Condition... conditions)`	Return a `Condition` that connects all argument `conditions` with `Operator.OR`.
`static Condition`	`or(Condition left, Condition right)`	Return a `Condition` that connects all argument `conditions` with `Operator.OR`.
`static WindowSpecificationRowsStep`	`orderBy(Collection<? extends OrderField<?>> fields)`	Create a `WindowSpecification` with an `ORDER BY` clause.
`static WindowSpecificationRowsStep`	`orderBy(Field<?>... fields)`	Create a `WindowSpecification` with an `ORDER BY` clause.
`static WindowSpecificationRowsStep`	`orderBy(OrderField<?>... fields)`	Create a `WindowSpecification` with an `ORDER BY` clause.
`static <T> Param<Object>`	`param()`	Create an unnamed parameter with a generic type (`Object` / `SQLDataType.OTHER`) and no initial value.
`static <T> Param<T>`	`param(Class<T> type)`	Create an unnamed parameter with a defined type and no initial value.
`static Param<Object>`	`param(String name)`	Create a named parameter with a generic type (`Object` / `SQLDataType.OTHER`) and no initial value.
`static <T> Param<T>`	`param(String name, Class<T> type)`	Create a named parameter with a defined type and no initial value.
`static <T> Param<T>`	`param(String name, DataType<T> type)`	Create a named parameter with a defined type and no initial value.
`static <T> 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> Param<T>`	`param(String name, T value)`	Create a named parameter with an initial value.
`static <T> Param<T>`	`param(DataType<T> type)`	Create an unnamed parameter with a defined type and no initial value.
`static <T> Param<T>`	`param(Field<T> field)`	Create an unnamed parameter with the defined type of another field and no initial value.
`static WindowSpecificationOrderByStep`	`partitionBy(Collection<? extends Field<?>> fields)`	Create a `WindowSpecification` with a `PARTITION BY` clause.
`static WindowSpecificationOrderByStep`	`partitionBy(Field<?>... fields)`	Create a `WindowSpecification` with a `PARTITION BY` clause.
`static OrderedAggregateFunction<BigDecimal>`	`percentileCont(Number number)`	The `percentile_cont([number]) within group (order by [column])` function.
`static OrderedAggregateFunction<BigDecimal>`	`percentileCont(Field<? extends Number> field)`	The `percentile_cont([number]) within group (order by [column])` function.
`static OrderedAggregateFunction<BigDecimal>`	`percentileDisc(Number number)`	The `percentile_disc([number]) within group (order by [column])` function.
`static OrderedAggregateFunction<BigDecimal>`	`percentileDisc(Field<? extends Number> field)`	The `percentile_disc([number]) within group (order by [column])` function.
`static WindowOverStep<BigDecimal>`	`percentRank()`	The `precent_rank() over ([analytic clause])` function.
`static OrderedAggregateFunction<Integer>`	`percentRank(Collection<? extends Field<?>> fields)`	The `percent_rank(expr) within group (order by [order clause])` ordered-set aggregate function.
`static OrderedAggregateFunction<Integer>`	`percentRank(Field<?>... fields)`	The `percent_rank(expr) within group (order by [order clause])` ordered-set aggregate function.
`static Field<BigDecimal>`	`pi()`	The `PI` literal.
`static Field<Integer>`	`position(String in, String search)`	Get the position(in, search) function.
`static Field<Integer>`	`position(String in, String search, int startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(String in, String search, Field<? extends Number> startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(String in, Field<String> search)`	Get the position(in, search) function.
`static Field<Integer>`	`position(String in, Field<String> search, int startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(String in, Field<String> search, Field<? extends Number> startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(Field<String> in, String search)`	Get the position(in, search) function.
`static Field<Integer>`	`position(Field<String> in, String search, int startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(Field<String> in, String search, Field<? extends Number> startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(Field<String> in, Field<String> search)`	Get the position(in, search) function.
`static Field<Integer>`	`position(Field<String> in, Field<String> search, int startIndex)`	Get the position(in, search, startindex) function.
`static Field<Integer>`	`position(Field<String> in, Field<String> search, Field<? extends Number> startIndex)`	Get the position(in, search, startindex) function.
`static Field<BigDecimal>`	`power(Number value, Number exponent)`	Get the power(field, exponent) function.
`static Field<BigDecimal>`	`power(Number value, Field<? extends Number> exponent)`	Get the power(field, exponent) function.
`static Field<BigDecimal>`	`power(Field<? extends Number> field, Number exponent)`	Get the power(field, exponent) function.
`static Field<BigDecimal>`	`power(Field<? extends Number> field, Field<? extends Number> exponent)`	Get the power(field, exponent) function.
`static ConstraintFinalStep`	`primaryKey(String... fields)`	Create an unnamed (system named) `PRIMARY KEY` constraint.
`static ConstraintFinalStep`	`primaryKey(Field<?>... fields)`	Create an unnamed (system named) `PRIMARY KEY` constraint.
`static ConstraintFinalStep`	`primaryKey(Name... fields)`	Create an unnamed (system named) `PRIMARY KEY` constraint.
`static <T> Field<T>`	`prior(Field<T> field)`	Add the Oracle-specific `PRIOR` unary operator before a field (to be used along with `CONNECT BY` clauses).
`static Privilege`	`privilege(String privilege)`	Create a new privilege reference.
`static AggregateFunction<BigDecimal>`	`product(Field<? extends Number> field)`	Get the product over a numeric field: product(field).
`static AggregateFunction<BigDecimal>`	`productDistinct(Field<? extends Number> field)`	Get the sum over a numeric field: product(distinct field).
`static Field<Integer>`	`quarter(Temporal value)`	Get the quarter of a date.
`static Field<Integer>`	`quarter(Date value)`	Get the quarter of a date.
`static Field<Integer>`	`quarter(Field<?> field)`	Get the quarter of a date.
`static Queries`	`queries(Collection<? extends Query> queries)`	Wrap a collection of queries.
`static Queries`	`queries(Query... queries)`	Wrap a collection of queries.
`static RowCountQuery`	`query(String sql)`	Create a new query holding plain SQL.
`static RowCountQuery`	`query(String sql, Object... bindings)`	Create a new query holding plain SQL.
`static RowCountQuery`	`query(String sql, QueryPart... parts)`	Create a new query holding plain SQL.
`static RowCountQuery`	`query(SQL sql)`	Create a new query holding plain SQL.
`static QueryPart`	`queryPart(String sql)`	Deprecated. - 3.6.0 - [#3854] - Use `sql(String)` instead
`static QueryPart`	`queryPart(String sql, Object... bindings)`	Deprecated. - 3.6.0 - [#3854] - Use `sql(String, Object...)` instead
`static QueryPart`	`queryPart(String sql, QueryPart... parts)`	Deprecated. - 3.6.0 - [#3854] - Use `sql(String, QueryPart...)` instead
`static Name`	`quotedName(String unqualifiedName)`	Create a new SQL identifier using an unqualified, quoted name.
`static Name`	`quotedName(String... qualifiedName)`	Create a new SQL identifier using a qualified, quoted name.
`static Name`	`quotedName(Collection<String> qualifiedName)`	Create a new SQL identifier using a qualified, quoted name.
`static Field<BigDecimal>`	`rad(Number value)`	Calculate radians from degrees from this field.
`static Field<BigDecimal>`	`rad(Field<? extends Number> field)`	Calculate radians from degrees from this field.
`static Field<BigDecimal>`	`rand()`	Get the rand() function.
`static WindowSpecificationRowsAndStep`	`rangeBetweenCurrentRow()`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationRowsAndStep`	`rangeBetweenFollowing(int number)`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationRowsAndStep`	`rangeBetweenPreceding(int number)`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationRowsAndStep`	`rangeBetweenUnboundedFollowing()`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationRowsAndStep`	`rangeBetweenUnboundedPreceding()`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationExcludeStep`	`rangeCurrentRow()`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationExcludeStep`	`rangeFollowing(int number)`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationExcludeStep`	`rangePreceding(int number)`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationExcludeStep`	`rangeUnboundedFollowing()`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowSpecificationExcludeStep`	`rangeUnboundedPreceding()`	Create a `WindowSpecification` with a `RANGE` clause.
`static WindowOverStep<Integer>`	`rank()`	The `rank() over ([analytic clause])` function.
`static OrderedAggregateFunction<Integer>`	`rank(Collection<? extends Field<?>> fields)`	The `rank(expr) within group (order by [order clause])` ordered-set aggregate function.
`static OrderedAggregateFunction<Integer>`	`rank(Field<?>... fields)`	The `rank(expr) within group (order by [order clause])` ordered-set aggregate function.
`static WindowOverStep<BigDecimal>`	`ratioToReport(Number number)`	The `ratio_to_report([expression]) over ([analytic clause])` function.
`static WindowOverStep<BigDecimal>`	`ratioToReport(Field<? extends Number> field)`	The `ratio_to_report([expression]) over ([analytic clause])` function.
`static <T1> RecordType<Record>`	`recordType(Collection<? extends Field<?>> fields)`	Create a `RecordType` of an arbitrary degree.
`static <T1> RecordType<Record>`	`recordType(Field<?>[] fields)`	Create a `RecordType` of an arbitrary degree.
`static <T1> RecordType<Record1<T1>>`	`recordType(Field<T1> field1)`	Create a `RecordType` of degree `1`.
`static <T1,T2> RecordType<Record2<T1,T2>>`	`recordType(Field<T1> field1, Field<T2> field2)`	Create a `RecordType` of degree `2`.
`static <T1,T2,T3> RecordType<Record3<T1,T2,T3>>`	`recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3)`	Create a `RecordType` of degree `3`.
`static <T1,T2,T3,T4> RecordType<Record4<T1,T2,T3,T4>>`	`recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)`	Create a `RecordType` of degree `4`.
`static <T1,T2,T3,T4,T5> RecordType<Record5<T1,T2,T3,T4,T5>>`	`recordType(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)`	Create a `RecordType` of degree `5`.
`static <T1,T2,T3,T4,T5,T6> 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 a `RecordType` of degree `6`.
`static <T1,T2,T3,T4,T5,T6,T7> 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 a `RecordType` of degree `7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> 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 a `RecordType` of degree `8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> 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 a `RecordType` of degree `9`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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 a `RecordType` of degree `10`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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 a `RecordType` of degree `11`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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 a `RecordType` of degree `12`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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 a `RecordType` of degree `13`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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 a `RecordType` of degree `14`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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 a `RecordType` of degree `15`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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 a `RecordType` of degree `16`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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 a `RecordType` of degree `17`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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 a `RecordType` of degree `18`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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 a `RecordType` of degree `19`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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 a `RecordType` of degree `20`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> 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 a `RecordType` of degree `21`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> 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 a `RecordType` of degree `22`.
`static AggregateFunction<BigDecimal>`	`regrAvgX(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_AVGX` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrAvgY(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_AVGY` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrCount(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_COUNT` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrIntercept(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_INTERCEPT` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrR2(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_R2` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrSlope(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_SLOPE` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrSXX(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_SXX` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrSXY(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_SXY` linear regression function.
`static AggregateFunction<BigDecimal>`	`regrSYY(Field<? extends Number> y, Field<? extends Number> x)`	Get the `REGR_SYY` linear regression function.
`static Field<String>`	`repeat(String field, int count)`	Get the repeat(field, count) function.
`static Field<String>`	`repeat(String field, Field<? extends Number> count)`	Get the repeat(field, count) function.
`static RepeatUntilStep`	`repeat(Collection<? extends Statement> statements)`	Create a `REPEAT` loop for use in procedural code.
`static Field<String>`	`repeat(Field<String> field, int count)`	Get the repeat(count) function.
`static Field<String>`	`repeat(Field<String> field, Field<? extends Number> count)`	Get the repeat(field, count) function.
`static RepeatUntilStep`	`repeat(Statement... statements)`	Create a `REPEAT` loop for use in procedural code.
`static Field<String>`	`replace(Field<String> field, String search)`	Get the replace(field, search) function.
`static Field<String>`	`replace(Field<String> field, String search, String replace)`	Get the replace(field, search, replace) function.
`static Field<String>`	`replace(Field<String> field, Field<String> search)`	Get the replace(field, search) function.
`static Field<String>`	`replace(Field<String> field, Field<String> search, Field<String> replace)`	Get the replace(field, search, replace) function.
`static ResultQuery<Record>`	`resultQuery(String sql)`	Create a new query holding plain SQL.
`static ResultQuery<Record>`	`resultQuery(String sql, Object... bindings)`	Create a new query holding plain SQL.
`static ResultQuery<Record>`	`resultQuery(String sql, QueryPart... parts)`	Create a new query holding plain SQL.
`static ResultQuery<Record>`	`resultQuery(SQL sql)`	Create a new query holding plain SQL.
`static Field<String>`	`reverse(String value)`	Get the `reverse(field)` function.
`static Field<String>`	`reverse(Field<String> field)`	Get the `reverse(field)` function.
`static RevokeOnStep`	`revoke(Collection<? extends Privilege> privileges)`	Revoke privileges on table from user or role.
`static RevokeOnStep`	`revoke(Privilege privilege)`	Revoke a privilege on table from user or role.
`static RevokeOnStep`	`revoke(Privilege... privileges)`	Revoke privileges on table from user or role.
`static RevokeOnStep`	`revokeGrantOptionFor(Collection<? extends Privilege> privileges)`	Revoke grant option for some privileges on a table from user or role.
`static RevokeOnStep`	`revokeGrantOptionFor(Privilege privilege)`	Revoke grant option for a privilege on a table from user or role.
`static RevokeOnStep`	`revokeGrantOptionFor(Privilege... privileges)`	Revoke grant option for some privileges on a table from user or role.
`static Field<String>`	`right(String field, int length)`	Get the right outermost characters from a string.
`static Field<String>`	`right(String field, Field<? extends Number> length)`	Get the right outermost characters from a string.
`static Field<String>`	`right(Field<String> field, int length)`	Get the right outermost characters from a string.
`static Field<String>`	`right(Field<String> field, Field<? extends Number> length)`	Get the right outermost characters from a string.
`static Role`	`role(String name)`	Create a new role reference.
`static Role`	`role(Name name)`	Create a new role reference.
`static GroupField`	`rollup(Field<?>... fields)`	Create a ROLLUP(field1, field2, .., fieldn) grouping field.
`static GroupField`	`rollup(FieldOrRow... fields)`	Create a ROLLUP(field1, field2, .., fieldn) grouping field.
`static <T extends Number> Field<T>`	`round(Field<T> field)`	Get rounded value of a numeric field: round(field).
`static <T extends Number> Field<T>`	`round(Field<T> field, int decimals)`	Get rounded value of a numeric field: round(field, decimals).
`static <T extends Number> Field<T>`	`round(T value)`	Get rounded value of a numeric field: round(field).
`static <T extends Number> Field<T>`	`round(T value, int decimals)`	Get rounded value of a numeric field: round(field, decimals).
`static RowN`	`row(Object... values)`	Create a row value expression of degree `N > 22`.
`static RowN`	`row(Collection<?> values)`	Create a row value expression of degree `N > 22`.
`static RowN`	`row(Field<?>... values)`	Create a row value expression of degree `N > 22`.
`static <T1> Row1<T1>`	`row(Field<T1> t1)`	Create a row value expression of degree `1`.
`static <T1,T2> Row2<T1,T2>`	`row(Field<T1> t1, Field<T2> t2)`	Create a row value expression of degree `2`.
`static <T1,T2,T3> Row3<T1,T2,T3>`	`row(Field<T1> t1, Field<T2> t2, Field<T3> t3)`	Create a row value expression of degree `3`.
`static <T1,T2,T3,T4> Row4<T1,T2,T3,T4>`	`row(Field<T1> t1, Field<T2> t2, Field<T3> t3, Field<T4> t4)`	Create a row value expression of degree `4`.
`static <T1,T2,T3,T4,T5> 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 degree `5`.
`static <T1,T2,T3,T4,T5,T6> 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 degree `6`.
`static <T1,T2,T3,T4,T5,T6,T7> 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 degree `7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> 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 degree `8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> 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 degree `9`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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 degree `10`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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 degree `11`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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 degree `12`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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 degree `13`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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 degree `14`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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 degree `15`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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)`	Create a row value expression of degree `16`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>`	`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, Field<T17> t17)`	Create a row value expression of degree `17`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>`	`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, Field<T17> t17, Field<T18> t18)`	Create a row value expression of degree `18`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>`	`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, Field<T17> t17, Field<T18> t18, Field<T19> t19)`	Create a row value expression of degree `19`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>`	`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, Field<T17> t17, Field<T18> t18, Field<T19> t19, Field<T20> t20)`	Create a row value expression of degree `20`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>`	`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, Field<T17> t17, Field<T18> t18, Field<T19> t19, Field<T20> t20, Field<T21> t21)`	Create a row value expression of degree `21`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>`	`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, Field<T17> t17, Field<T18> t18, Field<T19> t19, Field<T20> t20, Field<T21> t21, Field<T22> t22)`	Create a row value expression of degree `22`.
`static <T1> Row1<T1>`	`row(T1 t1)`	Create a row value expression of degree `1`.
`static <T1,T2> Row2<T1,T2>`	`row(T1 t1, T2 t2)`	Create a row value expression of degree `2`.
`static <T1,T2,T3> Row3<T1,T2,T3>`	`row(T1 t1, T2 t2, T3 t3)`	Create a row value expression of degree `3`.
`static <T1,T2,T3,T4> Row4<T1,T2,T3,T4>`	`row(T1 t1, T2 t2, T3 t3, T4 t4)`	Create a row value expression of degree `4`.
`static <T1,T2,T3,T4,T5> Row5<T1,T2,T3,T4,T5>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)`	Create a row value expression of degree `5`.
`static <T1,T2,T3,T4,T5,T6> Row6<T1,T2,T3,T4,T5,T6>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)`	Create a row value expression of degree `6`.
`static <T1,T2,T3,T4,T5,T6,T7> Row7<T1,T2,T3,T4,T5,T6,T7>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)`	Create a row value expression of degree `7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Row8<T1,T2,T3,T4,T5,T6,T7,T8>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)`	Create a row value expression of degree `8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)`	Create a row value expression of degree `9`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)`	Create a row value expression of degree `10`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11)`	Create a row value expression of degree `11`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12)`	Create a row value expression of degree `12`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13)`	Create a row value expression of degree `13`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14)`	Create a row value expression of degree `14`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15)`	Create a row value expression of degree `15`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16)`	Create a row value expression of degree `16`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17)`	Create a row value expression of degree `17`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18)`	Create a row value expression of degree `18`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19)`	Create a row value expression of degree `19`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20)`	Create a row value expression of degree `20`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21)`	Create a row value expression of degree `21`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>`	`row(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22)`	Create a row value expression of degree `22`.
`static <T1> Field<Record1<T1>>`	`rowField(Row1<T1> row)`	EXPERIMENTAL: Turn a row value expression of degree `1` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Field<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`rowField(Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> row)`	EXPERIMENTAL: Turn a row value expression of degree `10` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Field<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`rowField(Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> row)`	EXPERIMENTAL: Turn a row value expression of degree `11` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Field<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`rowField(Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> row)`	EXPERIMENTAL: Turn a row value expression of degree `12` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Field<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`rowField(Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> row)`	EXPERIMENTAL: Turn a row value expression of degree `13` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Field<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`rowField(Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> row)`	EXPERIMENTAL: Turn a row value expression of degree `14` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Field<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`rowField(Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> row)`	EXPERIMENTAL: Turn a row value expression of degree `15` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Field<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`rowField(Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> row)`	EXPERIMENTAL: Turn a row value expression of degree `16` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Field<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`rowField(Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> row)`	EXPERIMENTAL: Turn a row value expression of degree `17` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Field<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`rowField(Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> row)`	EXPERIMENTAL: Turn a row value expression of degree `18` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Field<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	`rowField(Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> row)`	EXPERIMENTAL: Turn a row value expression of degree `19` into a `Field`.
`static <T1,T2> Field<Record2<T1,T2>>`	`rowField(Row2<T1,T2> row)`	EXPERIMENTAL: Turn a row value expression of degree `2` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Field<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	`rowField(Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> row)`	EXPERIMENTAL: Turn a row value expression of degree `20` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Field<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	`rowField(Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> row)`	EXPERIMENTAL: Turn a row value expression of degree `21` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Field<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	`rowField(Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> row)`	EXPERIMENTAL: Turn a row value expression of degree `22` into a `Field`.
`static <T1,T2,T3> Field<Record3<T1,T2,T3>>`	`rowField(Row3<T1,T2,T3> row)`	EXPERIMENTAL: Turn a row value expression of degree `3` into a `Field`.
`static <T1,T2,T3,T4> Field<Record4<T1,T2,T3,T4>>`	`rowField(Row4<T1,T2,T3,T4> row)`	EXPERIMENTAL: Turn a row value expression of degree `4` into a `Field`.
`static <T1,T2,T3,T4,T5> Field<Record5<T1,T2,T3,T4,T5>>`	`rowField(Row5<T1,T2,T3,T4,T5> row)`	EXPERIMENTAL: Turn a row value expression of degree `5` into a `Field`.
`static <T1,T2,T3,T4,T5,T6> Field<Record6<T1,T2,T3,T4,T5,T6>>`	`rowField(Row6<T1,T2,T3,T4,T5,T6> row)`	EXPERIMENTAL: Turn a row value expression of degree `6` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7> Field<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`rowField(Row7<T1,T2,T3,T4,T5,T6,T7> row)`	EXPERIMENTAL: Turn a row value expression of degree `7` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Field<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`rowField(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)`	EXPERIMENTAL: Turn a row value expression of degree `8` into a `Field`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Field<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`rowField(Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9> row)`	EXPERIMENTAL: Turn a row value expression of degree `9` into a `Field`.
`static Field<Record>`	`rowField(RowN row)`	EXPERIMENTAL: Turn a row value expression of arbitrary degree into a `Field`.
`static Field<Integer>`	`rownum()`	Retrieve the Oracle-specific `ROWNUM` pseudo-field.
`static WindowOverStep<Integer>`	`rowNumber()`	The `row_number() over ([analytic clause])` function.
`static WindowSpecificationRowsAndStep`	`rowsBetweenCurrentRow()`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationRowsAndStep`	`rowsBetweenFollowing(int number)`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationRowsAndStep`	`rowsBetweenPreceding(int number)`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationRowsAndStep`	`rowsBetweenUnboundedFollowing()`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationRowsAndStep`	`rowsBetweenUnboundedPreceding()`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationExcludeStep`	`rowsCurrentRow()`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationExcludeStep`	`rowsFollowing(int number)`	Create a `WindowSpecification` with a `ROWS` clause.
`static Table<Record>`	`rowsFrom(Table<?>... tables)`	Create a `ROWS FROM (tables...)` expression.
`static WindowSpecificationExcludeStep`	`rowsPreceding(int number)`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationExcludeStep`	`rowsUnboundedFollowing()`	Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationExcludeStep`	`rowsUnboundedPreceding()`	Create a `WindowSpecification` with a `ROWS` clause.
`static Field<String>`	`rpad(Field<String> field, int length)`	Get the rpad(field, length) function.
`static Field<String>`	`rpad(Field<String> field, int length, char character)`	Get the rpad(field, length, character) function.
`static Field<String>`	`rpad(Field<String> field, int length, String character)`	Get the rpad(field, length, character) function.
`static Field<String>`	`rpad(Field<String> field, Field<? extends Number> length)`	Get the rpad(field, length) function.
`static Field<String>`	`rpad(Field<String> field, Field<? extends Number> length, Field<String> character)`	Get the rpad(field, length, character) function.
`static Field<String>`	`rtrim(String value)`	Get the rtrim(field) function.
`static Field<String>`	`rtrim(String value, String characters)`	Get the `rtrim(field, characters)` or `trim(trailing characters from field)` function.
`static Field<String>`	`rtrim(Field<String> field)`	Get the rtrim(field) function.
`static Field<String>`	`rtrim(Field<String> field, Field<String> characters)`	Get the `rtrim(field, characters)` or `trim(trailing characters from field)` function.
`static Schema`	`schema(Name name)`	Create a qualified schema, given its schema name.
`static Schema`	`schemaByName(String name)`	Deprecated. - [#3843] - 3.6.0 - use `schema(Name)` instead
`static Field<Integer>`	`second(Temporal value)`	Get the second part of a date.
`static Field<Integer>`	`second(Date value)`	Get the second part of a date.
`static Field<Integer>`	`second(Field<?> field)`	Get the second part of a date.
`static SelectSelectStep<Record>`	`select(Collection<? extends SelectFieldOrAsterisk> fields)`	Create a new DSL subselect statement.
`static <T1> SelectSelectStep<Record1<T1>>`	`select(SelectField<T1> field1)`	Create a new DSL subselect statement.
`static <T1,T2> SelectSelectStep<Record2<T1,T2>>`	`select(SelectField<T1> field1, SelectField<T2> field2)`	Create a new DSL subselect statement.
`static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19)	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20)	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21)	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22)	Create a new DSL subselect statement.
`static SelectSelectStep<Record>`	`select(SelectFieldOrAsterisk... fields)`	Create a new DSL subselect statement.
`static SelectSelectStep<Record1<Integer>>`	`selectCount()`	Create a new DSL subselect statement for `COUNT(*)`.
`static SelectSelectStep<Record>`	`selectDistinct(Collection<? extends SelectFieldOrAsterisk> fields)`	Create a new DSL subselect statement.
`static <T1> SelectSelectStep<Record1<T1>>`	`selectDistinct(SelectField<T1> field1)`	Create a new DSL subselect statement.
`static <T1,T2> SelectSelectStep<Record2<T1,T2>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2)`	Create a new DSL subselect statement.
`static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18)`	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19)	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20)	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21)	Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22)	Create a new DSL subselect statement.
`static SelectSelectStep<Record>`	`selectDistinct(SelectFieldOrAsterisk... fields)`	Create a new DSL subselect statement.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(String sql)`	Create a new DSL select statement, projecting `*`.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(String sql, Object... bindings)`	Create a new DSL select statement, projecting `*`.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(String sql, QueryPart... parts)`	Create a new DSL select statement, projecting `*`.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(Name table)`	Create a new DSL select statement, projecting `*`.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(SQL sql)`	Create a new DSL select statement, projecting `*`.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(Table<R> table)`	Create a new DSL select statement, projecting the known columns from a table.
`static SelectSelectStep<Record1<Integer>>`	`selectOne()`	Create a new DSL subselect statement for a constant `1` literal.
`static SelectSelectStep<Record1<Integer>>`	`selectZero()`	Create a new DSL subselect statement for a constant `0` literal.
`static Sequence<BigInteger>`	`sequence(String sql)`	Deprecated. - 3.10 - [#6162] - Use `sequence(Name)` instead.
`static <T extends Number> Sequence<T>`	`sequence(String sql, Class<T> type)`	Deprecated. - 3.10 - [#6162] - Use `sequence(Name, Class)` instead.
`static <T extends Number> Sequence<T>`	`sequence(String sql, DataType<T> type)`	Deprecated. - 3.10 - [#6162] - Use `sequence(Name, DataType)` instead.
`static Sequence<BigInteger>`	`sequence(Name name)`	Create a qualified sequence, given its sequence name.
`static <T extends Number> Sequence<T>`	`sequence(Name name, Class<T> type)`	Create a qualified sequence, given its sequence name.
`static <T extends Number> Sequence<T>`	`sequence(Name name, DataType<T> type)`	Create a qualified sequence, given its sequence name.
`static <T extends Number> Sequence<T>`	`sequenceByName(Class<T> type, String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `sequence(Name, Class)` instead
`static Sequence<BigInteger>`	`sequenceByName(String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `sequence(Name)` instead
`static <T extends Number> Sequence<T>`	`sequenceByName(DataType<T> type, String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `sequence(Name, DataType)` instead
`static RowCountQuery`	`setCatalog(String catalog)`	Set the current catalog to a new value.
`static RowCountQuery`	`setCatalog(Catalog catalog)`	Set the current catalog to a new value.
`static RowCountQuery`	`setCatalog(Name catalog)`	Set the current catalog to a new value.
`static RowCountQuery`	`setSchema(String schema)`	Set the current schema to a new value.
`static RowCountQuery`	`setSchema(Name schema)`	Set the current schema to a new value.
`static RowCountQuery`	`setSchema(Schema schema)`	Set the current schema to a new value.
`static <T extends Number> Field<T>`	`shl(Field<T> value1, Number value2)`	The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shl(Field<T> field1, Field<? extends Number> field2)`	The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shl(T value1, Number value2)`	The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shl(T value1, Field<? extends Number> value2)`	The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shr(Field<T> value1, Number value2)`	The bitwise right shift operator.
`static <T extends Number> Field<T>`	`shr(Field<T> field1, Field<? extends Number> field2)`	The bitwise right shift operator.
`static <T extends Number> Field<T>`	`shr(T value1, Number value2)`	The bitwise right shift operator.
`static <T extends Number> Field<T>`	`shr(T value1, Field<? extends Number> value2)`	The bitwise right shift operator.
`static Field<Integer>`	`sign(Number value)`	Get the sign of a numeric field: sign(field).
`static Field<Integer>`	`sign(Field<? extends Number> field)`	Get the sign of a numeric field: sign(field).
`static Field<BigDecimal>`	`sin(Number value)`	Get the sine(field) function.
`static Field<BigDecimal>`	`sin(Field<? extends Number> field)`	Get the sine(field) function.
`static Field<BigDecimal>`	`sinh(Number value)`	Get the hyperbolic sine function: sinh(field).
`static Field<BigDecimal>`	`sinh(Field<? extends Number> field)`	Get the hyperbolic sine function: sinh(field).
`static Field<String>`	`space(int value)`	Get the SQL Server specific `SPACE()` function.
`static Field<String>`	`space(Field<Integer> value)`	Get the SQL Server specific `SPACE()` function.
`static SQL`	`sql(String sql)`	A custom SQL clause that can render arbitrary expressions.
`static SQL`	`sql(String sql, Object... bindings)`	A custom SQL clause that can render arbitrary expressions.
`static SQL`	`sql(String sql, QueryPart... parts)`	A custom SQL clause that can render arbitrary expressions.
`static Field<BigDecimal>`	`sqrt(Number value)`	Get the sqrt(field) function.
`static Field<BigDecimal>`	`sqrt(Field<? extends Number> field)`	Get the sqrt(field) function.
`static Block`	`statements(Collection<? extends Statement> statements)`	Wrap a collection of statements in an anonymous procedural block that does not wrap in `BEGIN ..`
`static Block`	`statements(Statement... statements)`	Wrap a collection of statements in an anonymous procedural block that does not wrap in `BEGIN ..`
`static AggregateFunction<BigDecimal>`	`stddevPop(Field<? extends Number> field)`	Get the population standard deviation of a numeric field: stddev_pop(field).
`static AggregateFunction<BigDecimal>`	`stddevSamp(Field<? extends Number> field)`	Get the sample standard deviation of a numeric field: stddev_samp(field).
`static Field<String>`	`substring(Field<String> field, int startingPosition)`	Get the substring(field, startingPosition) function.
`static Field<String>`	`substring(Field<String> field, int startingPosition, int length)`	Get the substring(field, startingPosition, length) function.
`static Field<String>`	`substring(Field<String> field, Field<? extends Number> startingPosition)`	Get the substring(field, startingPosition) function.
`static Field<String>`	`substring(Field<String> field, Field<? extends Number> startingPosition, Field<? extends Number> length)`	Get the substring(field, startingPosition, length) function.
`static AggregateFunction<BigDecimal>`	`sum(Field<? extends Number> field)`	Get the sum over a numeric field: sum(field).
`static AggregateFunction<BigDecimal>`	`sumDistinct(Field<? extends Number> field)`	Get the sum over a numeric field: sum(distinct field).
`static Field<String>`	`sysConnectByPath(Field<?> field, String separator)`	Retrieve the Oracle-specific `SYS_CONNECT_BY_PATH(field, separator)` function (to be used along with `CONNECT BY` clauses).
`static Table<?>`	`table(Object[] array)`	A synonym for `unnest(Object[])`.
`static Table<Record>`	`table(String sql)`	A custom SQL clause that can render arbitrary table expressions.
`static Table<Record>`	`table(String sql, Object... bindings)`	A custom SQL clause that can render arbitrary table expressions.
`static Table<Record>`	`table(String sql, QueryPart... parts)`	A custom SQL clause that can render arbitrary table expressions.
`static Table<?>`	`table(Collection<?> list)`	A synonym for `unnest(Collection)`.
`static Table<?>`	`table(ArrayRecord<?> array)`	A synonym for `unnest(ArrayRecord)`.
`static Table<?>`	`table(Field<?> cursor)`	A synonym for `unnest(Field)`.
`static Table<Record>`	`table(Name name)`	Create a qualified table, given its table name.
`static Table<Record>`	`table(Name name, Comment comment)`	Create a qualified table, given its table name.
`static <R extends Record> Table<R>`	`table(Result<R> result)`	Use a previously obtained result as a new `Table` that can be used in SQL statements through `values(RowN...)`.
`static <R extends Record> Table<R>`	`table(Select<R> select)`	A synonym for `TableLike.asTable()`, which might look a bit more fluent like this, to some users.
`static Table<Record>`	`table(SQL sql)`	A custom SQL clause that can render arbitrary table expressions.
`static <R extends Record> Table<R>`	`table(R record)`	Use a previously obtained record as a new Table
`static <R extends Record> Table<R>`	`table(R... records)`	Use a previously obtained set of records as a new Table
`static Table<Record>`	`tableByName(String... qualifiedName)`	Deprecated. - [#3843] - 3.6.0 - use `table(Name)` instead
`static Field<BigDecimal>`	`tan(Number value)`	Get the tangent(field) function.
`static Field<BigDecimal>`	`tan(Field<? extends Number> field)`	Get the tangent(field) function.
`static Field<BigDecimal>`	`tanh(Number value)`	Get the hyperbolic tangent function: tanh(field).
`static Field<BigDecimal>`	`tanh(Field<? extends Number> field)`	Get the hyperbolic tangent function: tanh(field).
`static Field<Time>`	`time(String value)`	Convert a string value to a `TIME`.
`static Field<Time>`	`time(Date value)`	Convert a temporal value to a `TIME`.
`static Field<Time>`	`time(Field<? extends Date> field)`	Convert a temporal value to a `TIME`.
`static Field<Timestamp>`	`timestamp(String value)`	Convert a string value to a `TIMESTAMP`.
`static Field<Timestamp>`	`timestamp(Date value)`	Convert a temporal value to a `TIMESTAMP`.
`static Field<Timestamp>`	`timestamp(Field<? extends Date> field)`	Convert a temporal value to a `TIMESTAMP`.
`static Field<Timestamp>`	`timestampAdd(Timestamp timestamp, Number interval)`	Add an interval to a timestamp.
`static Field<Timestamp>`	`timestampAdd(Timestamp date, Number interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<Timestamp>`	`timestampAdd(Timestamp date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<Timestamp>`	`timestampAdd(Field<Timestamp> date, Number interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<Timestamp>`	`timestampAdd(Field<Timestamp> timestamp, Field<? extends Number> interval)`	Add an interval to a timestamp.
`static Field<Timestamp>`	`timestampAdd(Field<Timestamp> date, Field<? extends Number> interval, DatePart datePart)`	Add an interval to a timestamp, given a date part.
`static Field<DayToSecond>`	`timestampDiff(Timestamp timestamp1, Timestamp timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`timestampDiff(Timestamp timestamp1, Field<Timestamp> timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`timestampDiff(Field<Timestamp> timestamp1, Timestamp timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`timestampDiff(Field<Timestamp> timestamp1, Field<Timestamp> timestamp2)`	Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<Timestamp>`	`timestampSub(Timestamp timestamp, Number interval)`	Subtract an interval from a timestamp.
`static Field<Timestamp>`	`timestampSub(Timestamp date, Number interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<Timestamp>`	`timestampSub(Timestamp date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<Timestamp>`	`timestampSub(Field<Timestamp> date, Number interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<Timestamp>`	`timestampSub(Field<Timestamp> timestamp, Field<? extends Number> interval)`	Subtract an interval from a timestamp.
`static Field<Timestamp>`	`timestampSub(Field<Timestamp> date, Field<? extends Number> interval, DatePart datePart)`	Subtract an interval from a timestamp, given a date part.
`static Field<Integer>`	`timezone(Temporal value)`	Get the timezone part of a date.
`static Field<Integer>`	`timezone(Date value)`	Get the timezone part of a date.
`static Field<Integer>`	`timezone(Field<?> field)`	Get the timezone part of a date.
`static Field<Integer>`	`timezoneHour(Temporal value)`	Get the timezoneHour part of a date.
`static Field<Integer>`	`timezoneHour(Date value)`	Get the timezoneHour part of a date.
`static Field<Integer>`	`timezoneHour(Field<?> field)`	Get the timezoneHour part of a date.
`static Field<Integer>`	`timezoneMinute(Temporal value)`	Get the timezoneMinute part of a date.
`static Field<Integer>`	`timezoneMinute(Date value)`	Get the timezoneMinute part of a date.
`static Field<Integer>`	`timezoneMinute(Field<?> field)`	Get the timezoneMinute part of a date.
`static Field<Date>`	`toDate(String value, String format)`	Parse a value to a `DATE`.
`static Field<Date>`	`toDate(String value, Field<String> format)`	Parse a value to a `DATE`.
`static Field<Date>`	`toDate(Field<String> value, String format)`	Parse a value to a `DATE`.
`static Field<Date>`	`toDate(Field<String> value, Field<String> format)`	Parse a value to a `DATE`.
`static Field<LocalDate>`	`toLocalDate(String value, String format)`	Parse a value to a `DATE`.
`static Field<LocalDate>`	`toLocalDate(String value, Field<String> format)`	Parse a value to a `DATE`.
`static Field<LocalDate>`	`toLocalDate(Field<String> value, String format)`	Parse a value to a `DATE`.
`static Field<LocalDate>`	`toLocalDate(Field<String> value, Field<String> format)`	Parse a value to a `DATE`.
`static Field<LocalDateTime>`	`toLocalDateTime(String value, String format)`	Parse a value to a `TIMESTAMP`.
`static Field<LocalDateTime>`	`toLocalDateTime(String value, Field<String> format)`	Parse a value to a `TIMESTAMP`.
`static Field<LocalDateTime>`	`toLocalDateTime(Field<String> value, String format)`	Parse a value to a `TIMESTAMP`.
`static Field<LocalDateTime>`	`toLocalDateTime(Field<String> value, Field<String> format)`	Parse a value to a `TIMESTAMP`.
`static Field<Timestamp>`	`toTimestamp(String value, String format)`	Parse a value to a `TIMESTAMP`.
`static Field<Timestamp>`	`toTimestamp(String value, Field<String> format)`	Parse a value to a `TIMESTAMP`.
`static Field<Timestamp>`	`toTimestamp(Field<String> value, String format)`	Parse a value to a `TIMESTAMP`.
`static Field<Timestamp>`	`toTimestamp(Field<String> value, Field<String> format)`	Parse a value to a `TIMESTAMP`.
`static Field<String>`	`translate(Field<String> text, String from, String to)`	Get the translate(field, from, to) function.
`static Field<String>`	`translate(Field<String> text, Field<String> from, Field<String> to)`	Get the translate(field, from, to) function.
`static Field<String>`	`trim(String value)`	Get the trim(field) function.
`static Field<String>`	`trim(String value, String characters)`	Get the `trim(field, characters)` or `trim(both characters from field)` function.
`static Field<String>`	`trim(Field<String> field)`	Get the trim(field) function.
`static Field<String>`	`trim(Field<String> field, Field<String> characters)`	Get the `trim(field, characters)` or `trim(both characters from field)` function.
`static True`	`trueCondition()`	Return a `Condition` that will always evaluate to true.
`static Field<Date>`	`trunc(Date date)`	Truncate a date to the beginning of the day.
`static Field<Date>`	`trunc(Date date, DatePart part)`	Truncate a date to a given datepart.
`static Field<Timestamp>`	`trunc(Timestamp timestamp)`	Truncate a timestamp to the beginning of the day.
`static Field<Timestamp>`	`trunc(Timestamp timestamp, DatePart part)`	Truncate a timestamp to a given datepart.
`static Field<LocalDate>`	`trunc(LocalDate date)`	Truncate a date to the beginning of the day.
`static Field<LocalDate>`	`trunc(LocalDate date, DatePart part)`	Truncate a date to a given datepart.
`static Field<LocalDateTime>`	`trunc(LocalDateTime timestamp)`	Truncate a timestamp to the beginning of the day.
`static Field<LocalDateTime>`	`trunc(LocalDateTime timestamp, DatePart part)`	Truncate a timestamp to a given datepart.
`static <T> Field<T>`	`trunc(Field<T> date)`	Truncate a date or a timestamp to the beginning of the day.
`static <T extends Number> Field<T>`	`trunc(Field<T> number, int decimals)`	Truncate a number to a given number of decimals.
`static <T> Field<T>`	`trunc(Field<T> date, DatePart part)`	Truncate a date or a timestamp to a given datepart.
`static <T extends Number> Field<T>`	`trunc(Field<T> number, Field<Integer> decimals)`	Truncate a number to a given number of decimals.
`static <T extends Number> Field<T>`	`trunc(T number)`	Truncate a number to a given number of decimals.
`static <T extends Number> Field<T>`	`trunc(T number, int decimals)`	Truncate a number to a given number of decimals.
`static <T extends Number> Field<T>`	`trunc(T number, Field<Integer> decimals)`	Truncate a number to a given number of decimals.
`static TruncateIdentityStep<Record>`	`truncate(String table)`	Create a new DSL truncate statement.
`static TruncateIdentityStep<Record>`	`truncate(Name table)`	Create a new DSL truncate statement.
`static <R extends Record> TruncateIdentityStep<R>`	`truncate(Table<R> table)`	Create a new DSL truncate statement.
`static TruncateIdentityStep<Record>`	`truncateTable(String table)`	Create a new DSL truncate statement.
`static TruncateIdentityStep<Record>`	`truncateTable(Name table)`	Create a new DSL truncate statement.
`static <R extends Record> TruncateIdentityStep<R>`	`truncateTable(Table<R> table)`	Create a new DSL truncate statement.
`static Param<Integer>`	`two()`	A `2` literal.
`static ConstraintFinalStep`	`unique(String... fields)`	Create an unnamed (system named) `UNIQUE` constraint.
`static ConstraintFinalStep`	`unique(Field<?>... fields)`	Create an unnamed (system named) `UNIQUE` constraint.
`static ConstraintFinalStep`	`unique(Name... fields)`	Create an unnamed (system named) `UNIQUE` constraint.
`static Condition`	`unique(Select<?> query)`	Create a unique condition.
`static Table<?>`	`unnest(Object[] array)`	Create a table from an array of values.
`static Table<?>`	`unnest(Collection<?> list)`	Create a table from a list of values.
`static Table<?>`	`unnest(ArrayRecord<?> array)`	Create a table from an array of values.
`static Table<?>`	`unnest(Field<?> cursor)`	Create a table from a field.
`static Name`	`unquotedName(String unqualifiedName)`	Create a new SQL identifier using an unqualified, quoted name.
`static Name`	`unquotedName(String... qualifiedName)`	Create a new SQL identifier using a qualified, quoted name.
`static Name`	`unquotedName(Collection<String> qualifiedName)`	Create a new SQL identifier using a qualified, quoted name.
`static <R extends Record> UpdateSetFirstStep<R>`	`update(Table<R> table)`	Create a new DSL update statement.
`static Field<String>`	`upper(String value)`	Get the upper(field) function.
`static Field<String>`	`upper(Field<String> field)`	Get the upper(field) function.
`static User`	`user(String name)`	Create a new user reference.
`static User`	`user(Name name)`	Create a new user reference.
`static DSLContext`	`using(String url)`	Create an executor from a JDBC connection URL.
`static DSLContext`	`using(String url, String username, String password)`	Create an executor from a JDBC connection URL.
`static DSLContext`	`using(String url, Properties properties)`	Create an executor from a JDBC connection URL.
`static DSLContext`	`using(Connection connection)`	Create an executor with a connection configured.
`static DSLContext`	`using(Connection connection, Settings settings)`	Create an executor with a connection, a dialect and settings configured.
`static DSLContext`	`using(Connection connection, SQLDialect dialect)`	Create an executor with a connection and a dialect configured.
`static DSLContext`	`using(Connection connection, SQLDialect dialect, Settings settings)`	Create an executor with a connection, a dialect and settings configured.
`static DSLContext`	`using(DataSource datasource, SQLDialect dialect)`	Create an executor with a data source and a dialect configured.
`static DSLContext`	`using(DataSource datasource, SQLDialect dialect, Settings settings)`	Create an executor with a data source, a dialect and settings configured.
`static DSLContext`	`using(Configuration configuration)`	Create an executor from a custom configuration.
`static DSLContext`	`using(ConnectionProvider connectionProvider, SQLDialect dialect)`	Create an executor with a custom connection provider and a dialect configured.
`static DSLContext`	`using(ConnectionProvider connectionProvider, SQLDialect dialect, Settings settings)`	Create an executor with a custom connection provider, a dialect and settings configured.
`static DSLContext`	`using(SQLDialect dialect)`	Create an executor with a dialect configured.
`static DSLContext`	`using(SQLDialect dialect, Settings settings)`	Create an executor with a dialect and settings configured.
`static Param<Boolean>`	`val(boolean value)`	Get a bind value.
`static Param<Byte>`	`val(byte value)`	Get a bind value.
`static Param<byte[]>`	`val(byte[] value)`	Get a bind value.
`static Param<Double>`	`val(double value)`	Get a bind value.
`static Param<Float>`	`val(float value)`	Get a bind value.
`static Param<Integer>`	`val(int value)`	Get a bind value.
`static Param<Long>`	`val(long value)`	Get a bind value.
`static Param<Short>`	`val(short value)`	Get a bind value.
`static Param<Boolean>`	`val(Boolean value)`	Get a bind value.
`static Param<Byte>`	`val(Byte value)`	Get a bind value.
`static Param<Double>`	`val(Double value)`	Get a bind value.
`static Param<Float>`	`val(Float value)`	Get a bind value.
`static Param<Integer>`	`val(Integer value)`	Get a bind value.
`static Param<Long>`	`val(Long value)`	Get a bind value.
`static <T> Param<T>`	`val(Object value, Class<T> type)`	Get a bind value with an associated type, taken from a field.
`static <T> Param<T>`	`val(Object value, DataType<T> type)`	Get a bind value with an associated type.
`static <T> Param<T>`	`val(Object value, Field<T> field)`	Get a bind value with an associated type, taken from a field.
`static Param<Short>`	`val(Short value)`	Get a bind value.
`static Param<String>`	`val(String value)`	Get a bind value.
`static Param<BigDecimal>`	`val(BigDecimal value)`	Get a bind value.
`static Param<BigInteger>`	`val(BigInteger value)`	Get a bind value.
`static Param<Date>`	`val(Date value)`	Get a bind value.
`static Param<Time>`	`val(Time value)`	Get a bind value.
`static Param<Timestamp>`	`val(Timestamp value)`	Get a bind value.
`static Param<Instant>`	`val(Instant value)`	Get a bind value.
`static Param<LocalDate>`	`val(LocalDate value)`	Get a bind value.
`static Param<LocalDateTime>`	`val(LocalDateTime value)`	Get a bind value.
`static Param<LocalTime>`	`val(LocalTime value)`	Get a bind value.
`static Param<OffsetDateTime>`	`val(OffsetDateTime value)`	Get a bind value.
`static Param<OffsetTime>`	`val(OffsetTime value)`	Get a bind value.
`static Param<UUID>`	`val(UUID value)`	Get a bind value.
`static Param<UByte>`	`val(UByte value)`	Get a bind value.
`static Param<UInteger>`	`val(UInteger value)`	Get a bind value.
`static Param<ULong>`	`val(ULong value)`	Get a bind value.
`static Param<UShort>`	`val(UShort value)`	Get a bind value.
`static <T> Param<T>`	`val(T value)`	Get a bind value.
`static Param<Boolean>`	`value(boolean value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Byte>`	`value(byte value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<byte[]>`	`value(byte[] value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Double>`	`value(double value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Float>`	`value(float value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Integer>`	`value(int value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Long>`	`value(long value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Short>`	`value(short value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Boolean>`	`value(Boolean value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Byte>`	`value(Byte value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Double>`	`value(Double value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Float>`	`value(Float value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Integer>`	`value(Integer value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Long>`	`value(Long value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static <T> Param<T>`	`value(Object value, Class<T> type)`	A synonym for `val(Object, Class)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static <T> Param<T>`	`value(Object value, DataType<T> type)`	A synonym for `val(Object, DataType)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static <T> Param<T>`	`value(Object value, Field<T> field)`	A synonym for `val(Object, Field)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Short>`	`value(Short value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<String>`	`value(String value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<BigDecimal>`	`value(BigDecimal value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<BigInteger>`	`value(BigInteger value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Date>`	`value(Date value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Time>`	`value(Time value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Timestamp>`	`value(Timestamp value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<Instant>`	`value(Instant value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<LocalDate>`	`value(LocalDate value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<LocalDateTime>`	`value(LocalDateTime value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<LocalTime>`	`value(LocalTime value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<OffsetDateTime>`	`value(OffsetDateTime value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<OffsetTime>`	`value(OffsetTime value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<UUID>`	`value(UUID value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<UByte>`	`value(UByte value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<UInteger>`	`value(UInteger value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<ULong>`	`value(ULong value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static Param<UShort>`	`value(UShort value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static <T> Param<T>`	`value(T value)`	A synonym for `val(Object)` to be used in Scala and Groovy, where `val` is a reserved keyword.
`static <T1> Table<Record1<T1>>`	`values(Row1<T1>... rows)`	Create a `VALUES()` expression of degree `1`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Table<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`values(Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>... rows)`	Create a `VALUES()` expression of degree `10`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Table<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`values(Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>... rows)`	Create a `VALUES()` expression of degree `11`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Table<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`values(Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>... rows)`	Create a `VALUES()` expression of degree `12`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Table<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`values(Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>... rows)`	Create a `VALUES()` expression of degree `13`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Table<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`values(Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>... rows)`	Create a `VALUES()` expression of degree `14`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Table<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`values(Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>... rows)`	Create a `VALUES()` expression of degree `15`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Table<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`values(Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>... rows)`	Create a `VALUES()` expression of degree `16`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Table<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`values(Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>... rows)`	Create a `VALUES()` expression of degree `17`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Table<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`values(Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>... rows)`	Create a `VALUES()` expression of degree `18`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Table<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	`values(Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>... rows)`	Create a `VALUES()` expression of degree `19`.
`static <T1,T2> Table<Record2<T1,T2>>`	`values(Row2<T1,T2>... rows)`	Create a `VALUES()` expression of degree `2`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Table<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	`values(Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>... rows)`	Create a `VALUES()` expression of degree `20`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Table<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	`values(Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>... rows)`	Create a `VALUES()` expression of degree `21`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Table<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	`values(Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>... rows)`	Create a `VALUES()` expression of degree `22`.
`static <T1,T2,T3> Table<Record3<T1,T2,T3>>`	`values(Row3<T1,T2,T3>... rows)`	Create a `VALUES()` expression of degree `3`.
`static <T1,T2,T3,T4> Table<Record4<T1,T2,T3,T4>>`	`values(Row4<T1,T2,T3,T4>... rows)`	Create a `VALUES()` expression of degree `4`.
`static <T1,T2,T3,T4,T5> Table<Record5<T1,T2,T3,T4,T5>>`	`values(Row5<T1,T2,T3,T4,T5>... rows)`	Create a `VALUES()` expression of degree `5`.
`static <T1,T2,T3,T4,T5,T6> Table<Record6<T1,T2,T3,T4,T5,T6>>`	`values(Row6<T1,T2,T3,T4,T5,T6>... rows)`	Create a `VALUES()` expression of degree `6`.
`static <T1,T2,T3,T4,T5,T6,T7> Table<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`values(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)`	Create a `VALUES()` expression of degree `7`.
`static <T1,T2,T3,T4,T5,T6,T7,T8> Table<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`values(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)`	Create a `VALUES()` expression of degree `8`.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Table<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`values(Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9>... rows)`	Create a `VALUES()` expression of degree `9`.
`static Table<Record>`	`values(RowN... rows)`	Create a `VALUES()` expression of arbitrary degree.
`static <T> Variable<T>`	`var(String name, DataType<T> type)`	Create a local variable reference for use in procedural code.
`static <T> Variable<T>`	`var(Name name, DataType<T> type)`	Create a local variable reference for use in procedural code.
`static <T> Variable<T>`	`variable(String name, DataType<T> type)`	A synonym for `var(Name, DataType)` to be used in Scala and Groovy, where `var` is a reserved keyword.
`static <T> Variable<T>`	`variable(Name name, DataType<T> type)`	A synonym for `var(Name, DataType)` to be used in Scala and Groovy, where `var` is a reserved keyword.
`static AggregateFunction<BigDecimal>`	`varPop(Field<? extends Number> field)`	Get the population variance of a numeric field: var_pop(field).
`static AggregateFunction<BigDecimal>`	`varSamp(Field<? extends Number> field)`	Get the sample variance of a numeric field: var_samp(field).
`static Field<Integer>`	`week(Temporal value)`	Get the week part of a date.
`static Field<Integer>`	`week(Date value)`	Get the week part of a date.
`static Field<Integer>`	`week(Field<?> field)`	Get the week part of a date.
`static <T> CaseConditionStep<T>`	`when(Condition condition, Field<T> result)`	Initialise a `Case` statement.
`static <T> CaseConditionStep<T>`	`when(Condition condition, Select<? extends Record1<T>> result)`	Initialise a `Case` statement.
`static <T> CaseConditionStep<T>`	`when(Condition condition, T result)`	Initialise a `Case` statement.
`static LoopStep`	`while_(Condition condition)`	Create a `WHILE` loop for use in procedural code.
`static <T extends Number> Field<T>`	`widthBucket(Field<T> field, Field<T> low, Field<T> high, Field<Integer> buckets)`
`static <T extends Number> Field<T>`	`widthBucket(Field<T> field, T low, T high, int buckets)`
`static WithAsStep`	`with(String alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep1`	`with(String alias, String fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`with(String alias, String... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep2`	`with(String alias, String fieldAlias1, String fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep3`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep4`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep5`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep6`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep7`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep8`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep9`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep10`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep11`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep12`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep13`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep14`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep15`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep16`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep17`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep18`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep19`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep20`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep21`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep22`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`with(String alias, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithStep`	`with(CommonTableExpression<?>... tables)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`with(Name alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep1`	`with(Name alias, Name fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`with(Name alias, Name... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep2`	`with(Name alias, Name fieldAlias1, Name fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep3`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep4`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep5`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep6`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep7`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep8`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep9`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep10`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep11`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep12`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep13`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep14`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep15`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep16`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep17`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep18`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep19`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep20`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep21`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep22`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`withRecursive(String alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep1`	`withRecursive(String alias, String fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`withRecursive(String alias, String... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep2`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep3`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep4`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep5`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep6`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep7`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep8`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep9`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep10`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep11`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep12`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep13`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep14`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep15`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep16`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep17`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep18`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep19`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep20`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep21`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep22`	withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`withRecursive(String alias, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithStep`	`withRecursive(CommonTableExpression<?>... tables)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`withRecursive(Name alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep1`	`withRecursive(Name alias, Name fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`withRecursive(Name alias, Name... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep2`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep3`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep4`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep5`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep6`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep7`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep8`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep9`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep10`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep11`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep12`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep13`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep14`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep15`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep16`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep17`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep18`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep19`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep20`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep21`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep22`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static Field<Integer>`	`year(Temporal value)`	Get the year part of a date.
`static Field<Integer>`	`year(Date value)`	Get the year part of a date.
`static Field<Integer>`	`year(Field<?> field)`	Get the year part of a date.
`static Param<Integer>`	`zero()`	A `0` literal.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- DSL
```
protected DSL()
```
  No instances.

Method Detail

using
```
public static DSLContext using(SQLDialect dialect)
```
Create an executor with a dialect configured.
Without a connection or data source, this executor cannot execute queries. Use it to render SQL only.

Parameters:

dialect - The dialect to use with objects created from this executor

using
```
public static DSLContext using(SQLDialect dialect,
                               Settings settings)
```
Create an executor with a dialect and settings configured.
Without a connection or data source, this executor cannot execute queries. Use it to render SQL only.

Parameters:

dialect - The dialect to use with objects created from this executor

settings - The runtime settings to apply to objects created from this executor

using
```
public static DSLContext using(String url)
```
Create an executor from a JDBC connection URL.
Clients must ensure connections are closed properly by calling DSLContext.close() on the resulting DSLContext. For example:
```
 // Auto-closing DSLContext instance to free resources
 try (DSLContext ctx = DSL.using("jdbc:h2:~/test")) {

     // ...
 }
 
```
Parameters:

url - The connection URL.

See Also:

DefaultConnectionProvider, JDBCUtils.dialect(String)

using

public static DSLContext using(String url,
                               String username,
                               String password)

Create an executor from a JDBC connection URL.

Clients must ensure connections are closed properly by calling DSLContext.close() on the resulting DSLContext. For example:

 // Auto-closing DSLContext instance to free resources
 try (DSLContext ctx = DSL.using("jdbc:h2:~/test", "sa", "")) {

     // ...
 }

Parameters:: url - The connection URL.; username - The connection user name.; password - The connection password.
See Also:: DefaultConnectionProvider, JDBCUtils.dialect(String)

using
```
public static DSLContext using(String url,
                               Properties properties)
```
Create an executor from a JDBC connection URL.
Clients must ensure connections are closed properly by calling DSLContext.close() on the resulting DSLContext. For example:
```
 // Auto-closing DSLContext instance to free resources
 try (DSLContext ctx = DSL.using("jdbc:h2:~/test", properties)) {

     // ...
 }
 
```
Parameters:

url - The connection URL.

properties - The connection properties.

See Also:

DefaultConnectionProvider, JDBCUtils.dialect(String)

using
```
public static DSLContext using(Connection connection)
```
Create an executor with a connection configured.
If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for using(Connection, Settings), guessing the SQLDialect using JDBCUtils.dialect(Connection)

Parameters:

connection - The connection to use with objects created from this executor

See Also:

DefaultConnectionProvider, JDBCUtils.dialect(Connection)

using
```
public static DSLContext using(Connection connection,
                               SQLDialect dialect)
```
Create an executor with a connection and a dialect configured.
If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for using(ConnectionProvider, SQLDialect, Settings) using a DefaultConnectionProvider

Parameters:

connection - The connection to use with objects created from this executor

dialect - The dialect to use with objects created from this executor

See Also:

DefaultConnectionProvider

using
```
public static DSLContext using(Connection connection,
                               Settings settings)
```
Create an executor with a connection, a dialect and settings configured.
If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for using(ConnectionProvider, SQLDialect, Settings) using a DefaultConnectionProvider and guessing the SQLDialect using JDBCUtils.dialect(Connection)

Parameters:

connection - The connection to use with objects created from this executor

settings - The runtime settings to apply to objects created from this executor

See Also:

DefaultConnectionProvider, JDBCUtils.dialect(Connection)

using
```
public static DSLContext using(Connection connection,
                               SQLDialect dialect,
                               Settings settings)
```
Create an executor with a connection, a dialect and settings configured.
If you provide a JDBC connection to a jOOQ Configuration, jOOQ will use that connection directly for creating statements.
This is a convenience constructor for using(ConnectionProvider, SQLDialect, Settings) using a DefaultConnectionProvider

Parameters:

connection - The connection to use with objects created from this executor

dialect - The dialect to use with objects created from this executor

settings - The runtime settings to apply to objects created from this executor

See Also:

DefaultConnectionProvider

using
```
public static DSLContext using(DataSource datasource,
                               SQLDialect dialect)
```
Create an executor with a data source and a dialect configured.
If you provide a JDBC data source to a jOOQ Configuration, jOOQ will use that data source for initialising connections, and creating statements.
This is a convenience constructor for using(ConnectionProvider, SQLDialect) using a DataSourceConnectionProvider

Parameters:

datasource - The data source to use with objects created from this executor

dialect - The dialect to use with objects created from this executor

See Also:

DataSourceConnectionProvider

using
```
public static DSLContext using(DataSource datasource,
                               SQLDialect dialect,
                               Settings settings)
```
Create an executor with a data source, a dialect and settings configured.
If you provide a JDBC data source to a jOOQ Configuration, jOOQ will use that data source for initialising connections, and creating statements.
This is a convenience constructor for using(ConnectionProvider, SQLDialect, Settings) using a DataSourceConnectionProvider

Parameters:

datasource - The data source to use with objects created from this executor

dialect - The dialect to use with objects created from this executor

settings - The runtime settings to apply to objects created from this executor

See Also:

DataSourceConnectionProvider

using
```
public static DSLContext using(ConnectionProvider connectionProvider,
                               SQLDialect dialect)
```
Create an executor with a custom connection provider and a dialect configured.

Parameters:

connectionProvider - The connection provider providing jOOQ with JDBC connections

dialect - The dialect to use with objects created from this executor

using
```
public static DSLContext using(ConnectionProvider connectionProvider,
                               SQLDialect dialect,
                               Settings settings)
```
Create an executor with a custom connection provider, a dialect and settings configured.

Parameters:

connectionProvider - The connection provider providing jOOQ with JDBC connections

dialect - The dialect to use with objects created from this executor

settings - The runtime settings to apply to objects created from this executor

using
```
public static DSLContext using(Configuration configuration)
```
Create an executor from a custom configuration.

Parameters:

configuration - The configuration

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep with(String alias)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String) for strictly non-recursive CTE and withRecursive(String) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep with(String alias,
                              String... fieldAliases)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep with(Name alias)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(Name) for strictly non-recursive CTE and withRecursive(Name) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep with(Name alias,
                              Name... fieldAliases)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(Name, Name...) for strictly non-recursive CTE and withRecursive(Name, Name...) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep with(String alias,
                              Function<? super Field<?>,? extends String> fieldNameFunction)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.
This works in a similar way as with(String, String...), except that all column names are produced by a function that receives the CTE's Select columns as input.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep1 with(String alias,
                               String fieldAlias1)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep2 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep3 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep4 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3,
                               String fieldAlias4)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep5 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3,
                               String fieldAlias4,
                               String fieldAlias5)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep6 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3,
                               String fieldAlias4,
                               String fieldAlias5,
                               String fieldAlias6)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep7 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3,
                               String fieldAlias4,
                               String fieldAlias5,
                               String fieldAlias6,
                               String fieldAlias7)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep8 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3,
                               String fieldAlias4,
                               String fieldAlias5,
                               String fieldAlias6,
                               String fieldAlias7,
                               String fieldAlias8)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep9 with(String alias,
                               String fieldAlias1,
                               String fieldAlias2,
                               String fieldAlias3,
                               String fieldAlias4,
                               String fieldAlias5,
                               String fieldAlias6,
                               String fieldAlias7,
                               String fieldAlias8,
                               String fieldAlias9)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep10 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep11 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep12 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep13 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep14 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep15 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep16 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep17 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16,
                                String fieldAlias17)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep18 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16,
                                String fieldAlias17,
                                String fieldAlias18)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep19 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16,
                                String fieldAlias17,
                                String fieldAlias18,
                                String fieldAlias19)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep20 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16,
                                String fieldAlias17,
                                String fieldAlias18,
                                String fieldAlias19,
                                String fieldAlias20)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep21 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16,
                                String fieldAlias17,
                                String fieldAlias18,
                                String fieldAlias19,
                                String fieldAlias20,
                                String fieldAlias21)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep22 with(String alias,
                                String fieldAlias1,
                                String fieldAlias2,
                                String fieldAlias3,
                                String fieldAlias4,
                                String fieldAlias5,
                                String fieldAlias6,
                                String fieldAlias7,
                                String fieldAlias8,
                                String fieldAlias9,
                                String fieldAlias10,
                                String fieldAlias11,
                                String fieldAlias12,
                                String fieldAlias13,
                                String fieldAlias14,
                                String fieldAlias15,
                                String fieldAlias16,
                                String fieldAlias17,
                                String fieldAlias18,
                                String fieldAlias19,
                                String fieldAlias20,
                                String fieldAlias21,
                                String fieldAlias22)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep1 with(Name alias,
                               Name fieldAlias1)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep2 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep3 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep4 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3,
                               Name fieldAlias4)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep5 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3,
                               Name fieldAlias4,
                               Name fieldAlias5)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep6 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3,
                               Name fieldAlias4,
                               Name fieldAlias5,
                               Name fieldAlias6)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep7 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3,
                               Name fieldAlias4,
                               Name fieldAlias5,
                               Name fieldAlias6,
                               Name fieldAlias7)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep8 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3,
                               Name fieldAlias4,
                               Name fieldAlias5,
                               Name fieldAlias6,
                               Name fieldAlias7,
                               Name fieldAlias8)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep9 with(Name alias,
                               Name fieldAlias1,
                               Name fieldAlias2,
                               Name fieldAlias3,
                               Name fieldAlias4,
                               Name fieldAlias5,
                               Name fieldAlias6,
                               Name fieldAlias7,
                               Name fieldAlias8,
                               Name fieldAlias9)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep10 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep11 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep12 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep13 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep14 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep15 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep16 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep17 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16,
                                Name fieldAlias17)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep18 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16,
                                Name fieldAlias17,
                                Name fieldAlias18)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep19 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16,
                                Name fieldAlias17,
                                Name fieldAlias18,
                                Name fieldAlias19)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep20 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16,
                                Name fieldAlias17,
                                Name fieldAlias18,
                                Name fieldAlias19,
                                Name fieldAlias20)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep21 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16,
                                Name fieldAlias17,
                                Name fieldAlias18,
                                Name fieldAlias19,
                                Name fieldAlias20,
                                Name fieldAlias21)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithAsStep22 with(Name alias,
                                Name fieldAlias1,
                                Name fieldAlias2,
                                Name fieldAlias3,
                                Name fieldAlias4,
                                Name fieldAlias5,
                                Name fieldAlias6,
                                Name fieldAlias7,
                                Name fieldAlias8,
                                Name fieldAlias9,
                                Name fieldAlias10,
                                Name fieldAlias11,
                                Name fieldAlias12,
                                Name fieldAlias13,
                                Name fieldAlias14,
                                Name fieldAlias15,
                                Name fieldAlias16,
                                Name fieldAlias17,
                                Name fieldAlias18,
                                Name fieldAlias19,
                                Name fieldAlias20,
                                Name fieldAlias21,
                                Name fieldAlias22)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

with
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WithStep with(CommonTableExpression<?>... tables)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
Reusable CommonTableExpression types can be constructed through
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(CommonTableExpression...) for strictly non-recursive CTE and withRecursive(CommonTableExpression...) for strictly recursive CTE.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep withRecursive(String alias)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String) for strictly non-recursive CTE and withRecursive(String) for strictly recursive CTE.
Note that the SQLDialect.H2 database only supports single-table, RECURSIVE common table expression lists.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep withRecursive(String alias,
                                       String... fieldAliases)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.
Note that the SQLDialect.H2 database only supports single-table, RECURSIVE common table expression lists.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep withRecursive(Name alias)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(Name) for strictly non-recursive CTE and withRecursive(Name) for strictly recursive CTE.
Note that the SQLDialect.H2 database only supports single-table, RECURSIVE common table expression lists.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep withRecursive(Name alias,
                                       Name... fieldAliases)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(Name, Name...) for strictly non-recursive CTE and withRecursive(Name, Name...) for strictly recursive CTE.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep withRecursive(String alias,
                                       Function<? super Field<?>,? extends String> fieldNameFunction)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.
Note that the SQLDialect.H2 database only supports single-table, RECURSIVE common table expression lists.
This works in a similar way as with(String, String...), except that all column names are produced by a function that receives the CTE's Select columns as input.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep1 withRecursive(String alias,
                                        String fieldAlias1)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep2 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep3 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep4 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3,
                                        String fieldAlias4)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep5 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3,
                                        String fieldAlias4,
                                        String fieldAlias5)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep6 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3,
                                        String fieldAlias4,
                                        String fieldAlias5,
                                        String fieldAlias6)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep7 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3,
                                        String fieldAlias4,
                                        String fieldAlias5,
                                        String fieldAlias6,
                                        String fieldAlias7)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep8 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3,
                                        String fieldAlias4,
                                        String fieldAlias5,
                                        String fieldAlias6,
                                        String fieldAlias7,
                                        String fieldAlias8)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep9 withRecursive(String alias,
                                        String fieldAlias1,
                                        String fieldAlias2,
                                        String fieldAlias3,
                                        String fieldAlias4,
                                        String fieldAlias5,
                                        String fieldAlias6,
                                        String fieldAlias7,
                                        String fieldAlias8,
                                        String fieldAlias9)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep10 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep11 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep12 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep13 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep14 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep15 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep16 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep17 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16,
                                         String fieldAlias17)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep18 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16,
                                         String fieldAlias17,
                                         String fieldAlias18)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep19 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16,
                                         String fieldAlias17,
                                         String fieldAlias18,
                                         String fieldAlias19)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep20 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16,
                                         String fieldAlias17,
                                         String fieldAlias18,
                                         String fieldAlias19,
                                         String fieldAlias20)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep21 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16,
                                         String fieldAlias17,
                                         String fieldAlias18,
                                         String fieldAlias19,
                                         String fieldAlias20,
                                         String fieldAlias21)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep22 withRecursive(String alias,
                                         String fieldAlias1,
                                         String fieldAlias2,
                                         String fieldAlias3,
                                         String fieldAlias4,
                                         String fieldAlias5,
                                         String fieldAlias6,
                                         String fieldAlias7,
                                         String fieldAlias8,
                                         String fieldAlias9,
                                         String fieldAlias10,
                                         String fieldAlias11,
                                         String fieldAlias12,
                                         String fieldAlias13,
                                         String fieldAlias14,
                                         String fieldAlias15,
                                         String fieldAlias16,
                                         String fieldAlias17,
                                         String fieldAlias18,
                                         String fieldAlias19,
                                         String fieldAlias20,
                                         String fieldAlias21,
                                         String fieldAlias22)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep1 withRecursive(Name alias,
                                        Name fieldAlias1)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep2 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep3 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep4 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3,
                                        Name fieldAlias4)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep5 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3,
                                        Name fieldAlias4,
                                        Name fieldAlias5)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep6 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3,
                                        Name fieldAlias4,
                                        Name fieldAlias5,
                                        Name fieldAlias6)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep7 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3,
                                        Name fieldAlias4,
                                        Name fieldAlias5,
                                        Name fieldAlias6,
                                        Name fieldAlias7)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep8 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3,
                                        Name fieldAlias4,
                                        Name fieldAlias5,
                                        Name fieldAlias6,
                                        Name fieldAlias7,
                                        Name fieldAlias8)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep9 withRecursive(Name alias,
                                        Name fieldAlias1,
                                        Name fieldAlias2,
                                        Name fieldAlias3,
                                        Name fieldAlias4,
                                        Name fieldAlias5,
                                        Name fieldAlias6,
                                        Name fieldAlias7,
                                        Name fieldAlias8,
                                        Name fieldAlias9)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep10 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep11 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep12 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep13 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep14 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep15 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep16 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep17 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16,
                                         Name fieldAlias17)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep18 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16,
                                         Name fieldAlias17,
                                         Name fieldAlias18)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep19 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16,
                                         Name fieldAlias17,
                                         Name fieldAlias18,
                                         Name fieldAlias19)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep20 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16,
                                         Name fieldAlias17,
                                         Name fieldAlias18,
                                         Name fieldAlias19,
                                         Name fieldAlias20)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep21 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16,
                                         Name fieldAlias17,
                                         Name fieldAlias18,
                                         Name fieldAlias19,
                                         Name fieldAlias20,
                                         Name fieldAlias21)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithAsStep22 withRecursive(Name alias,
                                         Name fieldAlias1,
                                         Name fieldAlias2,
                                         Name fieldAlias3,
                                         Name fieldAlias4,
                                         Name fieldAlias5,
                                         Name fieldAlias6,
                                         Name fieldAlias7,
                                         Name fieldAlias8,
                                         Name fieldAlias9,
                                         Name fieldAlias10,
                                         Name fieldAlias11,
                                         Name fieldAlias12,
                                         Name fieldAlias13,
                                         Name fieldAlias14,
                                         Name fieldAlias15,
                                         Name fieldAlias16,
                                         Name fieldAlias17,
                                         Name fieldAlias18,
                                         Name fieldAlias19,
                                         Name fieldAlias20,
                                         Name fieldAlias21,
                                         Name fieldAlias22)

Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.

The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(String, String...) for strictly non-recursive CTE and withRecursive(String, String...) for strictly recursive CTE.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static WithStep withRecursive(CommonTableExpression<?>... tables)
```
Create a WITH clause to supply subsequent SELECT, UPDATE, INSERT, DELETE, and MERGE statements with CommonTableExpressions.
Reusable CommonTableExpression types can be constructed through
The RECURSIVE keyword may be optional or unsupported in some databases, in case of which it will not be rendered. For optimal database interoperability and readability, however, it is suggested that you use with(CommonTableExpression...) for strictly non-recursive CTE and withRecursive(CommonTableExpression...) for strictly recursive CTE.
Note that the SQLDialect.H2 database only supports single-table, RECURSIVE common table expression lists.

selectFrom
```
@Support
public static <R extends Record> SelectWhereStep<R> selectFrom(Table<R> table)
```
Create a new DSL select statement, projecting the known columns from a table.
This will project the known columns from the argument table querying TableLike.fields(). If no known columns are available (e.g. because the table has been created using table(String)), then SELECT * is projected.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 SELECT table.col1, table.col2 FROM table
 
```

selectFrom
```
@Support
public static <R extends Record> SelectWhereStep<R> selectFrom(Name table)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 SELECT * FROM table
 
```
See Also:

table(Name)

selectFrom
```
@Support
@PlainSQL
public static <R extends Record> SelectWhereStep<R> selectFrom(SQL sql)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

table(SQL), SQL

selectFrom
```
@Support
@PlainSQL
public static <R extends Record> SelectWhereStep<R> selectFrom(String sql)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

table(String), sql(String), SQL

selectFrom
```
@Support
@PlainSQL
public static <R extends Record> SelectWhereStep<R> selectFrom(String sql,
                                                               Object... bindings)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

table(String, Object...), sql(String, Object...), SQL

selectFrom
```
@Support
@PlainSQL
public static <R extends Record> SelectWhereStep<R> selectFrom(String sql,
                                                               QueryPart... parts)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

table(String, QueryPart...), sql(String, QueryPart...), SQL

select
```
@Support
public static SelectSelectStep<Record> select(Collection<? extends SelectFieldOrAsterisk> fields)
```
Create a new DSL subselect statement.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 select(fields)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
Note that passing an empty collection conveniently produces SELECT * semantics, i.e. it:
- Renders SELECT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
- Renders SELECT * if not all columns are known, e.g. when using plain SQL
See Also:

DSLContext.select(Collection)

select
```
@Support
public static SelectSelectStep<Record> select(SelectFieldOrAsterisk... fields)
```
Create a new DSL subselect statement.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
Note that passing an empty collection conveniently produces SELECT * semantics, i.e. it:
- Renders SELECT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
- Renders SELECT * if not all columns are known, e.g. when using plain SQL
See Also:

DSLContext.select(SelectFieldOrAsterisk...)

select
```
@Support
public static <T1> SelectSelectStep<Record1<T1>> select(SelectField<T1> field1)
```
Create a new DSL subselect statement.
This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Field.in(Select), Field.equal(Select) and other predicate building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select
```
@Support
public static <T1,T2> SelectSelectStep<Record2<T1,T2>> select(SelectField<T1> field1,
                                                                          SelectField<T2> field2)
```
Create a new DSL subselect statement.
This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row2.in(Select), Row2.equal(Select) and other predicate building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> select(SelectField<T1> field1,
                                                                                            SelectField<T2> field2,
                                                                                            SelectField<T3> field3)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row3.in(Select), Row3.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>> select(SelectField<T1> field1,
                                                                                                              SelectField<T2> field2,
                                                                                                              SelectField<T3> field3,
                                                                                                              SelectField<T4> field4)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row4.in(Select), Row4.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, field4)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>> select(SelectField<T1> field1,
                                                                                                                                SelectField<T2> field2,
                                                                                                                                SelectField<T3> field3,
                                                                                                                                SelectField<T4> field4,
                                                                                                                                SelectField<T5> field5)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row5.in(Select), Row5.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, field4, field5)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> select(SelectField<T1> field1,
                                                                                                                                                  SelectField<T2> field2,
                                                                                                                                                  SelectField<T3> field3,
                                                                                                                                                  SelectField<T4> field4,
                                                                                                                                                  SelectField<T5> field5,
                                                                                                                                                  SelectField<T6> field6)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row6.in(Select), Row6.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field5, field6)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> select(SelectField<T1> field1,
                                                                                                                                                                    SelectField<T2> field2,
                                                                                                                                                                    SelectField<T3> field3,
                                                                                                                                                                    SelectField<T4> field4,
                                                                                                                                                                    SelectField<T5> field5,
                                                                                                                                                                    SelectField<T6> field6,
                                                                                                                                                                    SelectField<T7> field7)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row7.in(Select), Row7.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field6, field7)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> select(SelectField<T1> field1,
                                                                                                                                                                                      SelectField<T2> field2,
                                                                                                                                                                                      SelectField<T3> field3,
                                                                                                                                                                                      SelectField<T4> field4,
                                                                                                                                                                                      SelectField<T5> field5,
                                                                                                                                                                                      SelectField<T6> field6,
                                                                                                                                                                                      SelectField<T7> field7,
                                                                                                                                                                                      SelectField<T8> field8)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row8.in(Select), Row8.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field7, field8)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> select(SelectField<T1> field1,
                                                                                                                                                                                                        SelectField<T2> field2,
                                                                                                                                                                                                        SelectField<T3> field3,
                                                                                                                                                                                                        SelectField<T4> field4,
                                                                                                                                                                                                        SelectField<T5> field5,
                                                                                                                                                                                                        SelectField<T6> field6,
                                                                                                                                                                                                        SelectField<T7> field7,
                                                                                                                                                                                                        SelectField<T8> field8,
                                                                                                                                                                                                        SelectField<T9> field9)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row9.in(Select), Row9.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field8, field9)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> select(SelectField<T1> field1,
                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                             SelectField<T10> field10)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row10.in(Select), Row10.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field9, field10)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                 SelectField<T2> field2,
                                                                                                                                                                                                                                                 SelectField<T3> field3,
                                                                                                                                                                                                                                                 SelectField<T4> field4,
                                                                                                                                                                                                                                                 SelectField<T5> field5,
                                                                                                                                                                                                                                                 SelectField<T6> field6,
                                                                                                                                                                                                                                                 SelectField<T7> field7,
                                                                                                                                                                                                                                                 SelectField<T8> field8,
                                                                                                                                                                                                                                                 SelectField<T9> field9,
                                                                                                                                                                                                                                                 SelectField<T10> field10,
                                                                                                                                                                                                                                                 SelectField<T11> field11)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row11.in(Select), Row11.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field10, field11)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                                                     SelectField<T10> field10,
                                                                                                                                                                                                                                                                     SelectField<T11> field11,
                                                                                                                                                                                                                                                                     SelectField<T12> field12)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row12.in(Select), Row12.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field11, field12)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                         SelectField<T2> field2,
                                                                                                                                                                                                                                                                                         SelectField<T3> field3,
                                                                                                                                                                                                                                                                                         SelectField<T4> field4,
                                                                                                                                                                                                                                                                                         SelectField<T5> field5,
                                                                                                                                                                                                                                                                                         SelectField<T6> field6,
                                                                                                                                                                                                                                                                                         SelectField<T7> field7,
                                                                                                                                                                                                                                                                                         SelectField<T8> field8,
                                                                                                                                                                                                                                                                                         SelectField<T9> field9,
                                                                                                                                                                                                                                                                                         SelectField<T10> field10,
                                                                                                                                                                                                                                                                                         SelectField<T11> field11,
                                                                                                                                                                                                                                                                                         SelectField<T12> field12,
                                                                                                                                                                                                                                                                                         SelectField<T13> field13)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row13.in(Select), Row13.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field12, field13)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                             SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                             SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                             SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                             SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                             SelectField<T14> field14)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row14.in(Select), Row14.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field13, field14)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                 SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                 SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                 SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                 SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                 SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                 SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                 SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                 SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                 SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                 SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                 SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                 SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                 SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                 SelectField<T15> field15)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row15.in(Select), Row15.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field14, field15)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                     SelectField<T16> field16)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row16.in(Select), Row16.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field15, field16)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                         SelectField<T17> field17)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row17.in(Select), Row17.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field16, field17)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T18> field18)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row18.in(Select), Row18.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field17, field18)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T19> field19)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row19.in(Select), Row19.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field18, field19)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T20> field20)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row20.in(Select), Row20.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field19, field20)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T21> field21)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row21.in(Select), Row21.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field20, field21)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

select

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> select(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T22> field22)

Create a new DSL subselect statement.

This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row22.in(Select), Row22.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 select(field1, field2, field3, .., field21, field22)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.select(SelectFieldOrAsterisk...), select(SelectFieldOrAsterisk...)

selectDistinct
```
@Support
public static SelectSelectStep<Record> selectDistinct(Collection<? extends SelectFieldOrAsterisk> fields)
```
Create a new DSL subselect statement.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(fields)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
Note that passing an empty collection conveniently produces SELECT DISTINCT * semantics, i.e. it:
- Renders SELECT DISTINCT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
- Renders SELECT DISTINCT * if not all columns are known, e.g. when using plain SQL
See Also:

DSLContext.selectDistinct(Collection)

selectDistinct
```
@Support
public static SelectSelectStep<Record> selectDistinct(SelectFieldOrAsterisk... fields)
```
Create a new DSL subselect statement.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
Note that passing an empty collection conveniently produces SELECT DISTINCT * semantics, i.e. it:
- Renders SELECT DISTINCT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
- Renders SELECT DISTINCT * if not all columns are known, e.g. when using plain SQL
See Also:

DSLContext.selectDistinct(SelectFieldOrAsterisk...)

selectDistinct
```
@Support
public static <T1> SelectSelectStep<Record1<T1>> selectDistinct(SelectField<T1> field1)
```
Create a new DSL subselect statement.
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Field.in(Select), Field.equal(Select) and other predicate building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct
```
@Support
public static <T1,T2> SelectSelectStep<Record2<T1,T2>> selectDistinct(SelectField<T1> field1,
                                                                                  SelectField<T2> field2)
```
Create a new DSL subselect statement.
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row2.in(Select), Row2.equal(Select) and other predicate building methods taking subselect arguments.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> selectDistinct(SelectField<T1> field1,
                                                                                                    SelectField<T2> field2,
                                                                                                    SelectField<T3> field3)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row3.in(Select), Row3.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>> selectDistinct(SelectField<T1> field1,
                                                                                                                      SelectField<T2> field2,
                                                                                                                      SelectField<T3> field3,
                                                                                                                      SelectField<T4> field4)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row4.in(Select), Row4.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, field4)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>> selectDistinct(SelectField<T1> field1,
                                                                                                                                        SelectField<T2> field2,
                                                                                                                                        SelectField<T3> field3,
                                                                                                                                        SelectField<T4> field4,
                                                                                                                                        SelectField<T5> field5)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row5.in(Select), Row5.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, field4, field5)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                          SelectField<T2> field2,
                                                                                                                                                          SelectField<T3> field3,
                                                                                                                                                          SelectField<T4> field4,
                                                                                                                                                          SelectField<T5> field5,
                                                                                                                                                          SelectField<T6> field6)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row6.in(Select), Row6.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field5, field6)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                            SelectField<T2> field2,
                                                                                                                                                                            SelectField<T3> field3,
                                                                                                                                                                            SelectField<T4> field4,
                                                                                                                                                                            SelectField<T5> field5,
                                                                                                                                                                            SelectField<T6> field6,
                                                                                                                                                                            SelectField<T7> field7)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row7.in(Select), Row7.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field6, field7)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                              SelectField<T2> field2,
                                                                                                                                                                                              SelectField<T3> field3,
                                                                                                                                                                                              SelectField<T4> field4,
                                                                                                                                                                                              SelectField<T5> field5,
                                                                                                                                                                                              SelectField<T6> field6,
                                                                                                                                                                                              SelectField<T7> field7,
                                                                                                                                                                                              SelectField<T8> field8)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row8.in(Select), Row8.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field7, field8)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                SelectField<T2> field2,
                                                                                                                                                                                                                SelectField<T3> field3,
                                                                                                                                                                                                                SelectField<T4> field4,
                                                                                                                                                                                                                SelectField<T5> field5,
                                                                                                                                                                                                                SelectField<T6> field6,
                                                                                                                                                                                                                SelectField<T7> field7,
                                                                                                                                                                                                                SelectField<T8> field8,
                                                                                                                                                                                                                SelectField<T9> field9)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row9.in(Select), Row9.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field8, field9)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                     SelectField<T10> field10)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row10.in(Select), Row10.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field9, field10)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                         SelectField<T2> field2,
                                                                                                                                                                                                                                                         SelectField<T3> field3,
                                                                                                                                                                                                                                                         SelectField<T4> field4,
                                                                                                                                                                                                                                                         SelectField<T5> field5,
                                                                                                                                                                                                                                                         SelectField<T6> field6,
                                                                                                                                                                                                                                                         SelectField<T7> field7,
                                                                                                                                                                                                                                                         SelectField<T8> field8,
                                                                                                                                                                                                                                                         SelectField<T9> field9,
                                                                                                                                                                                                                                                         SelectField<T10> field10,
                                                                                                                                                                                                                                                         SelectField<T11> field11)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row11.in(Select), Row11.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field10, field11)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                                                                             SelectField<T10> field10,
                                                                                                                                                                                                                                                                             SelectField<T11> field11,
                                                                                                                                                                                                                                                                             SelectField<T12> field12)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row12.in(Select), Row12.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field11, field12)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                 SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                 SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                 SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                 SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                 SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                 SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                 SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                 SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                 SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                 SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                 SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                 SelectField<T13> field13)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row13.in(Select), Row13.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field12, field13)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                     SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                     SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                     SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                     SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                     SelectField<T14> field14)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row14.in(Select), Row14.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field13, field14)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                         SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                         SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                         SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                         SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                         SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                         SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                         SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                         SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                         SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                         SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                         SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                         SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                         SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                         SelectField<T15> field15)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row15.in(Select), Row15.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field14, field15)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                             SelectField<T16> field16)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row16.in(Select), Row16.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field15, field16)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T17> field17)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row17.in(Select), Row17.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field16, field17)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T18> field18)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row18.in(Select), Row18.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field17, field18)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                         SelectField<T19> field19)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row19.in(Select), Row19.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field18, field19)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                             SelectField<T20> field20)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row20.in(Select), Row20.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field19, field20)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 SelectField<T21> field21)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row21.in(Select), Row21.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field20, field21)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     SelectField<T22> field22)

Create a new DSL subselect statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row22.in(Select), Row22.equal(Select) and other predicate building methods taking subselect arguments.

Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:

As a subselect within another select
As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 selectDistinct(field1, field2, field3, .., field21, field22)
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);

See Also:: DSLContext.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectZero
```
@Support
public static SelectSelectStep<Record1<Integer>> selectZero()
```
Create a new DSL subselect statement for a constant 0 literal.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectZero()
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

zero(), DSLContext.selectZero()

selectOne
```
@Support
public static SelectSelectStep<Record1<Integer>> selectOne()
```
Create a new DSL subselect statement for a constant 1 literal.
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectOne()
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

one(), DSLContext.selectOne()

selectCount
```
@Support
public static SelectSelectStep<Record1<Integer>> selectCount()
```
Create a new DSL subselect statement for COUNT(*).
Unlike Select factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable SELECT statement. You can use this statement in two ways:
- As a subselect within another select
- As a statement, after attaching it using Attachable.attach(org.jooq.Configuration)
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 selectCount()
  .from(table1)
  .join(table2).on(field1.equal(field2))
  .where(field1.greaterThan(100))
  .orderBy(field2);
 
```
See Also:

count(), DSLContext.selectCount()

insertInto

@Support
public static <R extends Record> InsertSetStep<R> insertInto(Table<R> into)

Create a new DSL insert statement.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

This type of insert may feel more convenient to some users, as it uses the UPDATE statement's SET a = b syntax.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table)
   .set(field1, value1)
   .set(field2, value2)
   .newRecord()
   .set(field1, value3)
   .set(field2, value4)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table)

insertInto

@Support
public static <R extends Record,T1> InsertValuesStep1<R,T1> insertInto(Table<R> into,
                                                                                   Field<T1> field1)

Create a new DSL insert statement.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1)
   .values(field1)
   .values(field1)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field)

insertInto

@Support
public static <R extends Record,T1,T2> InsertValuesStep2<R,T1,T2> insertInto(Table<R> into,
                                                                                                     Field<T1> field1,
                                                                                                     Field<T2> field2)

Create a new DSL insert statement.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2)
   .values(field1, field2)
   .values(field1, field2)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3> InsertValuesStep3<R,T1,T2,T3> insertInto(Table<R> into,
                                                                                                                       Field<T1> field1,
                                                                                                                       Field<T2> field2,
                                                                                                                       Field<T3> field3)

Create a new DSL insert statement.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3)
   .values(field1, field2, field3)
   .values(field1, field2, field3)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, field4)
   .values(field1, field2, field3, field4)
   .values(field1, field2, field3, field4)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, field4, field5)
   .values(field1, field2, field3, field4, field5)
   .values(field1, field2, field3, field4, field5)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field5, field6)
   .values(valueA1, valueA2, valueA3, .., valueA5, valueA6)
   .values(valueB1, valueB2, valueB3, .., valueB5, valueB6)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field6, field7)
   .values(valueA1, valueA2, valueA3, .., valueA6, valueA7)
   .values(valueB1, valueB2, valueB3, .., valueB6, valueB7)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field7, field8)
   .values(valueA1, valueA2, valueA3, .., valueA7, valueA8)
   .values(valueB1, valueB2, valueB3, .., valueB7, valueB8)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field8, field9)
   .values(valueA1, valueA2, valueA3, .., valueA8, valueA9)
   .values(valueB1, valueB2, valueB3, .., valueB8, valueB9)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field9, field10)
   .values(valueA1, valueA2, valueA3, .., valueA9, valueA10)
   .values(valueB1, valueB2, valueB3, .., valueB9, valueB10)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field10, field11)
   .values(valueA1, valueA2, valueA3, .., valueA10, valueA11)
   .values(valueB1, valueB2, valueB3, .., valueB10, valueB11)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field11, field12)
   .values(valueA1, valueA2, valueA3, .., valueA11, valueA12)
   .values(valueB1, valueB2, valueB3, .., valueB11, valueB12)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field12, field13)
   .values(valueA1, valueA2, valueA3, .., valueA12, valueA13)
   .values(valueB1, valueB2, valueB3, .., valueB12, valueB13)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field13, field14)
   .values(valueA1, valueA2, valueA3, .., valueA13, valueA14)
   .values(valueB1, valueB2, valueB3, .., valueB13, valueB14)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field14, field15)
   .values(valueA1, valueA2, valueA3, .., valueA14, valueA15)
   .values(valueB1, valueB2, valueB3, .., valueB14, valueB15)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field15, field16)
   .values(valueA1, valueA2, valueA3, .., valueA15, valueA16)
   .values(valueB1, valueB2, valueB3, .., valueB15, valueB16)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field16, field17)
   .values(valueA1, valueA2, valueA3, .., valueA16, valueA17)
   .values(valueB1, valueB2, valueB3, .., valueB16, valueB17)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field17, field18)
   .values(valueA1, valueA2, valueA3, .., valueA17, valueA18)
   .values(valueB1, valueB2, valueB3, .., valueB17, valueB18)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field18, field19)
   .values(valueA1, valueA2, valueA3, .., valueA18, valueA19)
   .values(valueB1, valueB2, valueB3, .., valueB18, valueB19)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field19, field20)
   .values(valueA1, valueA2, valueA3, .., valueA19, valueA20)
   .values(valueB1, valueB2, valueB3, .., valueB19, valueB20)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public 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> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field20, field21)
   .values(valueA1, valueA2, valueA3, .., valueA20, valueA21)
   .values(valueB1, valueB2, valueB3, .., valueB20, valueB21)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public 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> 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.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2, field3, .., field21, field22)
   .values(valueA1, valueA2, valueA3, .., valueA21, valueA22)
   .values(valueB1, valueB2, valueB3, .., valueB21, valueB22)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)

insertInto

@Support
public static <R extends Record> InsertValuesStepN<R> insertInto(Table<R> into,
                                                                 Field<?>... fields)

Create a new DSL insert statement.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2)
   .values(valueA1, valueA2)
   .values(valueB1, valueB2)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Field...)

insertInto

@Support
public static <R extends Record> InsertValuesStepN<R> insertInto(Table<R> into,
                                                                 Collection<? extends Field<?>> fields)

Create a new DSL insert statement.

Unlike Insert factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable INSERT statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 insertInto(table, field1, field2)
   .values(valueA1, valueA2)
   .values(valueB1, valueB2)
   .onDuplicateKeyUpdate()
   .set(field1, value1)
   .set(field2, value2)

See Also:: DSLContext.insertInto(Table, Collection)

update

@Support
public static <R extends Record> UpdateSetFirstStep<R> update(Table<R> table)

Create a new DSL update statement.

Unlike Update factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable UPDATE statement.

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 update(table)
   .set(field1, value1)
   .set(field2, value2)
   .where(field1.greaterThan(100))

Note that some databases support table expressions more complex than simple table references. In CUBRID and MySQL, for instance, you can write

 update(t1.join(t2).on(t1.id.eq(t2.id)))
   .set(t1.value, value1)
   .set(t2.value, value2)
   .where(t1.id.eq(10))

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record> MergeUsingStep<R> mergeInto(Table<R> table)

Create a new DSL SQL standard MERGE statement.

Unlike Merge factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable MERGE statement.

This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:

dialect	support type	documentation
CUBRID	SQL:2008 standard and some enhancements	http://www.cubrid.org/manual/90/en/MERGE
DB2	SQL:2008 standard and major enhancements	http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. ibm.db2.udb.admin.doc/doc/r0010873.htm
HSQLDB	SQL:2008 standard	http://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA
Oracle	SQL:2008 standard and minor enhancements	http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ statements_9016.htm
SQL Server	Similar to SQL:2008 standard with some major enhancements	http://msdn.microsoft.com/de-de/library/bb510625.aspx
Sybase	Similar to SQL:2008 standard with some major enhancements	http://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html

Example:

 import static org.jooq.impl.DSL.*;

 // [...]

 mergeInto(table)
   .using(select)
   .on(condition)
   .whenMatchedThenUpdate()
   .set(field1, value1)
   .set(field2, value2)
   .whenNotMatchedThenInsert(field1, field2)
   .values(value1, value2)

Note: Using this method, you can also create an H2-specific MERGE statement without field specification. See also mergeInto(Table, Field...)

See Also:: DSLContext.mergeInto(Table)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1> MergeKeyStep1<R,T1> mergeInto(Table<R> table,
                                                                              Field<T1> field1)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2> MergeKeyStep2<R,T1,T2> mergeInto(Table<R> table,
                                                                                                Field<T1> field1,
                                                                                                Field<T2> field2)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3> MergeKeyStep3<R,T1,T2,T3> mergeInto(Table<R> table,
                                                                                                                  Field<T1> field1,
                                                                                                                  Field<T2> field2,
                                                                                                                  Field<T3> field3)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4> MergeKeyStep4<R,T1,T2,T3,T4> mergeInto(Table<R> table,
                                                                                                                                    Field<T1> field1,
                                                                                                                                    Field<T2> field2,
                                                                                                                                    Field<T3> field3,
                                                                                                                                    Field<T4> field4)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public 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> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public 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> 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)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table,
                                                            Field<?>... fields)

Create a new DSL merge statement (H2-specific syntax).

Unlike Merge factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable MERGE statement.

This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:

H2	H2 natively supports this special syntax	www.h2database.com/html/grammar.html#merge
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere	These databases can emulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions	See `mergeInto(Table)` for the standard MERGE statement

See Also:: DSLContext.mergeInto(Table, Field...)

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table,
                                                            Collection<? extends Field<?>> fields)

Create a new DSL merge statement (H2-specific syntax).

Unlike Merge factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable MERGE statement.

See Also:: DSLContext.mergeInto(Table, Collection)

deleteFrom
```
@Support
public static <R extends Record> DeleteWhereStep<R> deleteFrom(Table<R> table)
```
Create a new DSL delete statement.
Unlike Delete factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable DELETE statement.
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 deleteFrom(table)
   .where(field1.greaterThan(100))
 
```
Some but not all databases support aliased tables in delete statements.
See Also:

DSLContext.deleteFrom(Table)

delete

@Support
public static <R extends Record> DeleteWhereStep<R> delete(Table<R> table)

Create a new DSL delete statement.

This is an alias for deleteFrom(Table)

comment

@Support
public static Comment comment(String comment)

Create a comment.

commentOnTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnTable(String tableName)

Create a new DSL COMMENT ON TABLE statement.

See Also:: DSLContext.commentOnTable(String), AlterTableStep.comment(Comment)

commentOnTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnTable(Name tableName)

Create a new DSL COMMENT ON TABLE statement.

See Also:: DSLContext.commentOnTable(Name), AlterTableStep.comment(Comment)

commentOnTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnTable(Table<?> table)

Create a new DSL COMMENT ON TABLE statement.

See Also:: DSLContext.commentOnTable(Table), AlterTableStep.comment(Comment)

commentOnView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnView(String viewName)

Create a new DSL COMMENT ON VIEW statement.

See Also:: DSLContext.commentOnView(String), AlterViewStep.comment(Comment)

commentOnView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnView(Name viewName)

Create a new DSL COMMENT ON VIEW statement.

See Also:: DSLContext.commentOnView(Name), AlterViewStep.comment(Comment)

commentOnView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnView(Table<?> view)

Create a new DSL COMMENT ON VIEW statement.

See Also:: DSLContext.commentOnView(Table), AlterViewStep.comment(Comment)

commentOnColumn

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnColumn(Name columnName)

Create a new DSL COMMENT ON COLUMN statement.

See Also:: DSLContext.commentOnColumn(Name)

commentOnColumn

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CommentOnIsStep commentOnColumn(Field<?> field)

Create a new DSL COMMENT ON COLUMN statement.

See Also:: DSLContext.commentOnColumn(Field)

constraint
```
@Support
public static ConstraintTypeStep constraint()
```
Create an unnamed (system named) CONSTRAINT specification.

constraint

@Support
public static ConstraintTypeStep constraint(Name name)

Create a CONSTRAINT specification.

constraint

@Support
public static ConstraintTypeStep constraint(String name)

Create a CONSTRAINT specification.

primaryKey

@Support
public static ConstraintFinalStep primaryKey(String... fields)

Create an unnamed (system named) PRIMARY KEY constraint.

primaryKey

@Support
public static ConstraintFinalStep primaryKey(Name... fields)

Create an unnamed (system named) PRIMARY KEY constraint.

primaryKey

@Support
public static ConstraintFinalStep primaryKey(Field<?>... fields)

Create an unnamed (system named) PRIMARY KEY constraint.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStepN foreignKey(String... fields)

Add a FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStepN foreignKey(Name... fields)

Add a FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStepN foreignKey(Field<?>... fields)

Add a FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static <T1> ConstraintForeignKeyReferencesStep1<T1> foreignKey(Field<T1> field1)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static <T1,T2> ConstraintForeignKeyReferencesStep2<T1,T2> foreignKey(Field<T1> field1,
                                                                                        Field<T2> field2)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3> ConstraintForeignKeyReferencesStep3<T1,T2,T3> foreignKey(Field<T1> field1,
                                                                                                          Field<T2> field2,
                                                                                                          Field<T3> field3)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> 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 the CONSTRAINT.

foreignKey

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> 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 the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep1<?> foreignKey(Name field1)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep2<?,?> foreignKey(Name field1,
                                                                        Name field2)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep3<?,?,?> foreignKey(Name field1,
                                                                                Name field2,
                                                                                Name field3)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep4<?,?,?,?> foreignKey(Name field1,
                                                                                        Name field2,
                                                                                        Name field3,
                                                                                        Name field4)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep5<?,?,?,?,?> foreignKey(Name field1,
                                                                                                Name field2,
                                                                                                Name field3,
                                                                                                Name field4,
                                                                                                Name field5)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?> foreignKey(Name field1,
                                                                                                        Name field2,
                                                                                                        Name field3,
                                                                                                        Name field4,
                                                                                                        Name field5,
                                                                                                        Name field6)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep1<?> foreignKey(String field1)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep2<?,?> foreignKey(String field1,
                                                                        String field2)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep3<?,?,?> foreignKey(String field1,
                                                                                String field2,
                                                                                String field3)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep4<?,?,?,?> foreignKey(String field1,
                                                                                        String field2,
                                                                                        String field3,
                                                                                        String field4)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep5<?,?,?,?,?> foreignKey(String field1,
                                                                                                String field2,
                                                                                                String field3,
                                                                                                String field4,
                                                                                                String field5)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static ConstraintForeignKeyReferencesStep6<?,?,?,?,?,?> foreignKey(String field1,
                                                                                                        String field2,
                                                                                                        String field3,
                                                                                                        String field4,
                                                                                                        String field5,
                                                                                                        String field6)

Add an unnamed (system named) FOREIGN KEY clause to the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

foreignKey

@Support
public static 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 the CONSTRAINT.

unique

@Support
public static ConstraintFinalStep unique(String... fields)

Create an unnamed (system named) UNIQUE constraint.

unique

@Support
public static ConstraintFinalStep unique(Name... fields)

Create an unnamed (system named) UNIQUE constraint.

unique

@Support
public static ConstraintFinalStep unique(Field<?>... fields)

Create an unnamed (system named) UNIQUE constraint.

check

@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static ConstraintFinalStep check(Condition condition)

Create an unnamed (system named) CHECK constraint.

setCatalog

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
public static RowCountQuery setCatalog(String catalog)

Set the current catalog to a new value.

See Also:: catalog(Name)

setCatalog

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
public static RowCountQuery setCatalog(Name catalog)

Set the current catalog to a new value.

See Also:: catalog(Name)

setCatalog

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
public static RowCountQuery setCatalog(Catalog catalog)

Set the current catalog to a new value.

setSchema

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
public static RowCountQuery setSchema(String schema)

Set the current schema to a new value.

See Also:: schema(Name), DSLContext.setSchema(String)

setSchema

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
public static RowCountQuery setSchema(Name schema)

Set the current schema to a new value.

See Also:: schema(Name), DSLContext.setSchema(Name)

setSchema

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
public static RowCountQuery setSchema(Schema schema)

Set the current schema to a new value.

See Also:: DSLContext.setSchema(Schema)

createSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static CreateSchemaFinalStep createSchema(String schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSLContext.createSchema(String)

createSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static CreateSchemaFinalStep createSchema(Name schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSLContext.createSchema(Name)

createSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static CreateSchemaFinalStep createSchema(Schema schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSLContext.createSchema(Schema)

createSchemaIfNotExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static CreateSchemaFinalStep createSchemaIfNotExists(String schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSLContext.createSchemaIfNotExists(String)

createSchemaIfNotExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static CreateSchemaFinalStep createSchemaIfNotExists(Name table)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSLContext.createSchemaIfNotExists(Name)

createSchemaIfNotExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static CreateSchemaFinalStep createSchemaIfNotExists(Schema schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSLContext.createSchemaIfNotExists(Schema)

createTable
```
@Support
public static CreateTableColumnStep createTable(String table)
```
Create a new DSL CREATE TABLE statement.

See Also:

DSLContext.createTable(String)

createTable
```
@Support
public static CreateTableColumnStep createTable(Name table)
```
Create a new DSL CREATE TABLE statement.

See Also:

DSLContext.createTable(Name)

createTable
```
@Support
public static CreateTableColumnStep createTable(Table<?> table)
```
Create a new DSL CREATE TABLE statement.

See Also:

DSLContext.createTable(Table)

createTableIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static CreateTableColumnStep createTableIfNotExists(String table)

Create a new DSL CREATE TABLE statement.

See Also:: DSLContext.createTableIfNotExists(String)

createTableIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static CreateTableColumnStep createTableIfNotExists(Name table)

Create a new DSL CREATE TABLE statement.

See Also:: DSLContext.createTableIfNotExists(Name)

createTableIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static CreateTableColumnStep createTableIfNotExists(Table<?> table)

Create a new DSL CREATE TABLE statement.

See Also:: DSLContext.createTableIfNotExists(Table)

createTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static CreateTableColumnStep createTemporaryTable(String table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSLContext.createTemporaryTable(String)

createTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static CreateTableColumnStep createTemporaryTable(Name table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSLContext.createTemporaryTable(Name)

createTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static CreateTableColumnStep createTemporaryTable(Table<?> table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSLContext.createTemporaryTable(Table)

createGlobalTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static CreateTableColumnStep createGlobalTemporaryTable(String table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSLContext.createGlobalTemporaryTable(String)

createGlobalTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static CreateTableColumnStep createGlobalTemporaryTable(Name table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSLContext.createGlobalTemporaryTable(Name)

createGlobalTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static CreateTableColumnStep createGlobalTemporaryTable(Table<?> table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSLContext.createGlobalTemporaryTable(Table)

createView

@Support
public static CreateViewAsStep createView(String view,
                                          String... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSLContext.createView(String, String...)

createView

@Support
public static CreateViewAsStep createView(Name view,
                                          Name... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSLContext.createView(Name, Name...)

createView

@Support
public static CreateViewAsStep createView(Table<?> view,
                                          Field<?>... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSLContext.createView(Table, Field...)

createView
```
@Support
public static CreateViewAsStep createView(String view,
                                          Function<? super Field<?>,? extends String> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSLContext.createView(String, String...)

createView
```
@Support
public static CreateViewAsStep createView(Name view,
                                          Function<? super Field<?>,? extends Name> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSLContext.createView(Name, Name...)

createView
```
@Support
public static CreateViewAsStep createView(Table<?> view,
                                          Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSLContext.createView(Table, Field...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CreateViewAsStep createOrReplaceView(String view,
                                                   String... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:: DSLContext.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CreateViewAsStep createOrReplaceView(Name view,
                                                   Name... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:: DSLContext.createOrReplaceView(Name, Name...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CreateViewAsStep createOrReplaceView(Table<?> view,
                                                   Field<?>... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:: DSLContext.createOrReplaceView(Table, Field...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CreateViewAsStep createOrReplaceView(String view,
                                                   Function<? super Field<?>,? extends String> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSLContext.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CreateViewAsStep createOrReplaceView(Name view,
                                                   Function<? super Field<?>,? extends Name> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSLContext.createOrReplaceView(Name, Name...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static CreateViewAsStep createOrReplaceView(Table<?> view,
                                                   Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSLContext.createOrReplaceView(Table, Field...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateViewAsStep createViewIfNotExists(String view,
                                                     String... fields)

Create a new DSL CREATE VIEW IF NOT EXISTS statement.

See Also:: DSLContext.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateViewAsStep createViewIfNotExists(Name view,
                                                     Name... fields)

Create a new DSL CREATE VIEW IF NOT EXISTS statement.

See Also:: DSLContext.createViewIfNotExists(Name, Name...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateViewAsStep createViewIfNotExists(Table<?> view,
                                                     Field<?>... fields)

Create a new DSL CREATE VIEW IF NOT EXISTS statement.

See Also:: DSLContext.createViewIfNotExists(Table, Field...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateViewAsStep createViewIfNotExists(String view,
                                                     Function<? super Field<?>,? extends String> fieldNameFunction)

Create a new DSL CREATE VIEW IF NOT EXISTS statement.

This works like createViewIfNotExists(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSLContext.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateViewAsStep createViewIfNotExists(Name view,
                                                     Function<? super Field<?>,? extends Name> fieldNameFunction)

Create a new DSL CREATE VIEW IF NOT EXISTS statement.

This works like createViewIfNotExists(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSLContext.createViewIfNotExists(Name, Name...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateViewAsStep createViewIfNotExists(Table<?> view,
                                                     Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE VIEW IF NOT EXISTS statement.

This works like createViewIfNotExists(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSLContext.createViewIfNotExists(Table, Field...)

createType

@Support({H2,POSTGRES})
public static CreateTypeStep createType(String type)

Create a new DSL CREATE TYPE statement.

See Also:: DSLContext.createType(String)

createType

@Support({H2,POSTGRES})
public static CreateTypeStep createType(Name type)

Create a new DSL CREATE TYPE statement.

See Also:: DSLContext.createType(Name)

dropType

@Support({H2,POSTGRES})
public static DropTypeStep dropType(String type)

Create a new DSL DROP TYPE statement.

See Also:: dropType(String)

dropType

@Support({H2,POSTGRES})
public static DropTypeStep dropType(Name type)

Create a new DSL DROP TYPE statement.

See Also:: dropType(Name)

dropType

@Support({H2,POSTGRES})
public static DropTypeStep dropType(String... type)

Create a new DSL DROP TYPE statement.

See Also:: dropType(String...)

dropType

@Support({H2,POSTGRES})
public static DropTypeStep dropType(Name... type)

Create a new DSL DROP TYPE statement.

See Also:: dropType(Name...)

dropType

@Support({H2,POSTGRES})
public static DropTypeStep dropType(Collection<?> type)

Create a new DSL DROP TYPE statement.

See Also:: dropType(Collection)

dropTypeIfExists

@Support({H2,POSTGRES})
public static DropTypeStep dropTypeIfExists(String type)

Create a new DSL DROP TYPE statement.

See Also:: dropTypeIfExists(String)

dropTypeIfExists

@Support({H2,POSTGRES})
public static DropTypeStep dropTypeIfExists(Name type)

Create a new DSL DROP TYPE statement.

See Also:: dropTypeIfExists(Name)

dropTypeIfExists

@Support({H2,POSTGRES})
public static DropTypeStep dropTypeIfExists(String... type)

Create a new DSL DROP TYPE statement.

See Also:: dropTypeIfExists(String...)

dropTypeIfExists

@Support({H2,POSTGRES})
public static DropTypeStep dropTypeIfExists(Name... type)

Create a new DSL DROP TYPE statement.

See Also:: dropTypeIfExists(Name...)

dropTypeIfExists

@Support({H2,POSTGRES})
public static DropTypeStep dropTypeIfExists(Collection<?> type)

Create a new DSL DROP TYPE statement.

See Also:: dropTypeIfExists(Collection)

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createIndex()

Create a new DSL CREATE INDEX statement.

See Also:: DSLContext.createIndex()

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createIndex(String index)

Create a new DSL CREATE INDEX statement.

See Also:: DSLContext.createIndex(String)

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createIndex(Name index)

Create a new DSL CREATE INDEX statement.

See Also:: DSLContext.createIndex(Name)

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createIndex(Index index)

Create a new DSL CREATE INDEX statement.

See Also:: DSLContext.createIndex(Index)

createIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateIndexStep createIndexIfNotExists(String index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:: DSLContext.createIndexIfNotExists(String)

createIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateIndexStep createIndexIfNotExists(Name index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:: DSLContext.createIndexIfNotExists(Name)

createIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static CreateIndexStep createIndexIfNotExists(Index index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:: DSLContext.createIndexIfNotExists(Index)

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createUniqueIndex()

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSLContext.createUniqueIndex()

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createUniqueIndex(String index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSLContext.createUniqueIndex(String)

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createUniqueIndex(Name index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSLContext.createUniqueIndex(Name)

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static CreateIndexStep createUniqueIndex(Index index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSLContext.createUniqueIndex(Index)

createUniqueIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static CreateIndexStep createUniqueIndexIfNotExists(String index)

Create a new DSL CREATE UNIQUE INDEX IF NOT EXISTS statement.

See Also:: DSLContext.createUniqueIndexIfNotExists(String)

createUniqueIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static CreateIndexStep createUniqueIndexIfNotExists(Name index)

Create a new DSL CREATE UNIQUE INDEX IF NOT EXISTS statement.

See Also:: DSLContext.createUniqueIndexIfNotExists(Name)

createUniqueIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static CreateIndexStep createUniqueIndexIfNotExists(Index index)

Create a new DSL CREATE UNIQUE INDEX IF NOT EXISTS statement.

See Also:: DSLContext.createUniqueIndexIfNotExists(Index)

createSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static CreateSequenceFlagsStep createSequence(String sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSLContext.createSequence(String)

createSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static CreateSequenceFlagsStep createSequence(Name sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSLContext.createSequence(Name)

createSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static CreateSequenceFlagsStep createSequence(Sequence<?> sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSLContext.createSequence(Sequence)

createSequenceIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static CreateSequenceFlagsStep createSequenceIfNotExists(String sequence)

Create a new DSL CREATE SEQUENCE IF NOT EXISTS statement.

See Also:: DSLContext.createSequenceIfNotExists(String)

createSequenceIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static CreateSequenceFlagsStep createSequenceIfNotExists(Name sequence)

Create a new DSL CREATE SEQUENCE IF NOT EXISTS statement.

See Also:: DSLContext.createSequenceIfNotExists(Name)

createSequenceIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static CreateSequenceFlagsStep createSequenceIfNotExists(Sequence<?> sequence)

Create a new DSL CREATE SEQUENCE IF NOT EXISTS statement.

See Also:: DSLContext.createSequenceIfNotExists(Sequence)

alterSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static AlterSequenceStep<BigInteger> alterSequence(String sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSLContext.alterSequence(String)

alterSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static AlterSequenceStep<BigInteger> alterSequence(Name sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSLContext.alterSequence(Name)

alterSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> AlterSequenceStep<T> alterSequence(Sequence<T> sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSLContext.alterSequence(Sequence)

alterSequenceIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES})
public static AlterSequenceStep<BigInteger> alterSequenceIfExists(String sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSLContext.alterSequenceIfExists(String)

alterSequenceIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES})
public static AlterSequenceStep<BigInteger> alterSequenceIfExists(Name sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSLContext.alterSequenceIfExists(Name)

alterSequenceIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES})
public static <T extends Number> AlterSequenceStep<T> alterSequenceIfExists(Sequence<T> sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSLContext.alterSequenceIfExists(Sequence)

alterTable
```
@Support
public static AlterTableStep alterTable(String table)
```
Create a new DSL ALTER TABLE statement.

See Also:

DSLContext.alterTable(String)

alterTable
```
@Support
public static AlterTableStep alterTable(Name table)
```
Create a new DSL ALTER TABLE statement.

See Also:

DSLContext.alterTable(Name)

alterTable
```
@Support
public static AlterTableStep alterTable(Table<?> table)
```
Create a new DSL ALTER TABLE statement.

See Also:

DSLContext.alterTable(Table)

alterTableIfExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,ORACLE,POSTGRES,SQLSERVER})
public static AlterTableStep alterTableIfExists(String table)

Create a new DSL ALTER TABLE statement.

See Also:: DSLContext.alterTableIfExists(String)

alterTableIfExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,ORACLE,POSTGRES,SQLSERVER})
public static AlterTableStep alterTableIfExists(Name table)

Create a new DSL ALTER TABLE statement.

See Also:: DSLContext.alterTableIfExists(Name)

alterTableIfExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,ORACLE,POSTGRES,SQLSERVER})
public static AlterTableStep alterTableIfExists(Table<?> table)

Create a new DSL ALTER TABLE statement.

See Also:: DSLContext.alterTableIfExists(Table)

alterSchema

@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES,VERTICA})
public static AlterSchemaStep alterSchema(String schema)

Create a new DSL ALTER SCHEMA statement.

See Also:: DSLContext.alterSchema(String)

alterSchema

@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES,VERTICA})
public static AlterSchemaStep alterSchema(Name schema)

Create a new DSL ALTER SCHEMA statement.

See Also:: DSLContext.alterSchema(Name)

alterSchema

@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES,VERTICA})
public static AlterSchemaStep alterSchema(Schema schema)

Create a new DSL ALTER SCHEMA statement.

See Also:: DSLContext.alterSchema(Schema)

alterSchemaIfExists
```
@Support(H2)
public static AlterSchemaStep alterSchemaIfExists(String schema)
```
Create a new DSL ALTER SCHEMA statement.

See Also:

DSLContext.alterSchemaIfExists(String)

alterSchemaIfExists
```
@Support(H2)
public static AlterSchemaStep alterSchemaIfExists(Name schema)
```
Create a new DSL ALTER SCHEMA statement.

See Also:

DSLContext.alterSchemaIfExists(Name)

alterSchemaIfExists
```
@Support(H2)
public static AlterSchemaStep alterSchemaIfExists(Schema schema)
```
Create a new DSL ALTER SCHEMA statement.

See Also:

DSLContext.alterSchemaIfExists(Schema)

alterView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static AlterViewStep alterView(String view)

Create a new DSL ALTER VIEW statement.

See Also:: DSLContext.alterView(String)

alterView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static AlterViewStep alterView(Name view)

Create a new DSL ALTER VIEW statement.

See Also:: DSLContext.alterView(Name)

alterView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
public static AlterViewStep alterView(Table<?> view)

Create a new DSL ALTER VIEW statement.

See Also:: DSLContext.alterView(Table)

alterViewIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES,SQLSERVER})
public static AlterViewStep alterViewIfExists(String view)

Create a new DSL ALTER VIEW statement.

See Also:: DSLContext.alterViewIfExists(String)

alterViewIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES,SQLSERVER})
public static AlterViewStep alterViewIfExists(Name view)

Create a new DSL ALTER VIEW statement.

See Also:: DSLContext.alterViewIfExists(Name)

alterViewIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES,SQLSERVER})
public static AlterViewStep alterViewIfExists(Table<?> view)

Create a new DSL ALTER VIEW statement.

See Also:: DSLContext.alterViewIfExists(Table)

alterIndex

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
public static AlterIndexOnStep alterIndex(String index)

Create a new DSL ALTER INDEX statement.

See Also:: DSLContext.alterIndex(String)

alterIndex

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
public static AlterIndexOnStep alterIndex(Name index)

Create a new DSL ALTER INDEX statement.

See Also:: DSLContext.alterIndex(Name)

alterIndex

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
public static AlterIndexOnStep alterIndex(Index index)

Create a new DSL ALTER INDEX statement.

See Also:: DSLContext.alterIndex(Index)

alterIndexIfExists

@Support({AURORA_POSTGRES,DB2,H2,ORACLE,POSTGRES})
public static AlterIndexStep alterIndexIfExists(String index)

Create a new DSL ALTER INDEX statement.

See Also:: DSLContext.alterIndexIfExists(String)

alterIndexIfExists

@Support({AURORA_POSTGRES,DB2,H2,ORACLE,POSTGRES})
public static AlterIndexStep alterIndexIfExists(Name index)

Create a new DSL ALTER INDEX statement.

See Also:: DSLContext.alterIndexIfExists(Name)

alterIndexIfExists

@Support({AURORA_POSTGRES,DB2,H2,ORACLE,POSTGRES})
public static AlterIndexStep alterIndexIfExists(Index index)

Create a new DSL ALTER INDEX statement.

See Also:: DSLContext.alterIndexIfExists(Index)

dropSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static DropSchemaStep dropSchema(String schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSLContext.dropSchema(String)

dropSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static DropSchemaStep dropSchema(Name schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSLContext.dropSchema(Name)

dropSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static DropSchemaStep dropSchema(Schema schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSLContext.dropSchema(Schema)

dropSchemaIfExists

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static DropSchemaStep dropSchemaIfExists(String schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSLContext.dropSchemaIfExists(String)

dropSchemaIfExists

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static DropSchemaStep dropSchemaIfExists(Name schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSLContext.dropSchemaIfExists(Name)

dropSchemaIfExists

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
public static DropSchemaStep dropSchemaIfExists(Schema schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSLContext.dropSchemaIfExists(Schema)

dropView
```
@Support
public static DropViewFinalStep dropView(String view)
```
Create a new DSL DROP VIEW statement.

See Also:

DSLContext.dropView(String)

dropView
```
@Support
public static DropViewFinalStep dropView(Name view)
```
Create a new DSL DROP VIEW statement.

See Also:

DSLContext.dropView(Name)

dropView
```
@Support
public static DropViewFinalStep dropView(Table<?> view)
```
Create a new DSL DROP VIEW statement.

See Also:

DSLContext.dropView(Table)

dropViewIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static DropViewFinalStep dropViewIfExists(String view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSLContext.dropViewIfExists(String)

dropViewIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static DropViewFinalStep dropViewIfExists(Name view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSLContext.dropViewIfExists(Name)

dropViewIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static DropViewFinalStep dropViewIfExists(Table<?> view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSLContext.dropViewIfExists(Table)

dropTable
```
@Support
public static DropTableStep dropTable(String table)
```
Create a new DSL DROP TABLE statement.

See Also:

DSLContext.dropTable(String)

dropTable
```
@Support
public static DropTableStep dropTable(Name table)
```
Create a new DSL DROP TABLE statement.

See Also:

DSLContext.dropTable(Name)

dropTable
```
@Support
public static DropTableStep dropTable(Table<?> table)
```
Create a new DSL DROP TABLE statement.

See Also:

DSLContext.dropTable(Table)

dropTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static DropTableStep dropTemporaryTable(String table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:: DSLContext.dropTemporaryTable(String)

dropTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static DropTableStep dropTemporaryTable(Name table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:: DSLContext.dropTemporaryTable(Name)

dropTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
public static DropTableStep dropTemporaryTable(Table<?> table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:: DSLContext.dropTemporaryTable(Table)

dropTableIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static DropTableStep dropTableIfExists(String table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSLContext.dropTableIfExists(String)

dropTableIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static DropTableStep dropTableIfExists(Name table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSLContext.dropTableIfExists(Name)

dropTableIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static DropTableStep dropTableIfExists(Table<?> table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSLContext.dropTableIfExists(Table)

dropIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static DropIndexOnStep dropIndex(String index)

Create a new DSL DROP INDEX statement.

See Also:: DSLContext.dropIndex(String)

dropIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static DropIndexOnStep dropIndex(Name index)

Create a new DSL DROP INDEX statement.

See Also:: DSLContext.dropIndex(Name)

dropIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static DropIndexOnStep dropIndex(Index index)

Create a new DSL DROP INDEX statement.

See Also:: DSLContext.dropIndex(Index)

dropIndexIfExists
```
@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static DropIndexOnStep dropIndexIfExists(String index)
```
Create a new DSL DROP INDEX IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSLContext.dropIndexIfExists(String)

dropIndexIfExists
```
@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static DropIndexOnStep dropIndexIfExists(Name index)
```
Create a new DSL DROP INDEX IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSLContext.dropIndexIfExists(Name)

dropIndexIfExists
```
@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
public static DropIndexOnStep dropIndexIfExists(Index index)
```
Create a new DSL DROP INDEX IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSLContext.dropIndexIfExists(Index)

dropSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> DropSequenceFinalStep dropSequence(String sequence)

Create a new DSL DROP SEQUENCE statement.

See Also:: DSLContext.dropSequence(String)

dropSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> DropSequenceFinalStep dropSequence(Name sequence)

Create a new DSL DROP SEQUENCE statement.

See Also:: DSLContext.dropSequence(Name)

dropSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> DropSequenceFinalStep dropSequence(Sequence<?> sequence)

Create a new DSL DROP SEQUENCE statement.

See Also:: DSLContext.dropSequence(Sequence)

dropSequenceIfExists
```
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> DropSequenceFinalStep dropSequenceIfExists(String sequence)
```
Create a new DSL DROP SEQUENCE IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSLContext.dropSequenceIfExists(String)

dropSequenceIfExists
```
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> DropSequenceFinalStep dropSequenceIfExists(Name sequence)
```
Create a new DSL DROP SEQUENCE IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSLContext.dropSequenceIfExists(Name)

dropSequenceIfExists
```
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> DropSequenceFinalStep dropSequenceIfExists(Sequence<?> sequence)
```
Create a new DSL DROP SEQUENCE IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSLContext.dropSequenceIfExists(Sequence)

truncate

@Support
public static TruncateIdentityStep<Record> truncate(String table)

Create a new DSL truncate statement.

Synonym for truncateTable(String)

truncate

@Support
public static TruncateIdentityStep<Record> truncate(Name table)

Create a new DSL truncate statement.

Synonym for truncateTable(Name)

truncate

@Support
public static <R extends Record> TruncateIdentityStep<R> truncate(Table<R> table)

Create a new DSL truncate statement.

Synonym for truncateTable(Table)

truncateTable
```
@Support
public static TruncateIdentityStep<Record> truncateTable(String table)
```
Create a new DSL truncate statement.
Unlike Delete factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable DELETE statement.
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 truncate(table);
 
```
Simulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:
Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:
```
 truncate(table)
   .restartIdentity()
   .cascade()
 
```
These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.
See Also:

DSLContext.truncate(String)

truncateTable
```
@Support
public static TruncateIdentityStep<Record> truncateTable(Name table)
```
Create a new DSL truncate statement.
Unlike Delete factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable DELETE statement.
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 truncate(table);
 
```
Simulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:
Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:
```
 truncate(table)
   .restartIdentity()
   .cascade()
 
```
These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.
See Also:

DSLContext.truncate(Name)

truncateTable
```
@Support
public static <R extends Record> TruncateIdentityStep<R> truncateTable(Table<R> table)
```
Create a new DSL truncate statement.
Unlike Delete factory methods in the DSLContext API, this creates an unattached, and thus not directly renderable or executable DELETE statement.
Example:
```
 import static org.jooq.impl.DSL.*;

 // [...]

 truncate(table);
 
```
Simulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:
Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:
```
 truncate(table)
   .restartIdentity()
   .cascade()
 
```
These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.
See Also:

DSLContext.truncate(Table)

all
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record> QuantifiedSelect<R> all(Select<R> select)
```
Create an ALL quantified select to be used in quantified comparison predicate expressions.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

all
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> QuantifiedSelect<Record1<T>> all(T... array)
```
Create an ALL quantified select to be used in quantified comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects will render a subselect unnesting the array.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

all
```
@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES})
public static <T> QuantifiedSelect<Record1<T>> all(Field<T[]> array)
```
Create an ALL quantified select to be used in quantified comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects will render a subselect unnesting the array.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

all
```
@Support
@SafeVarargs
public static <T> QuantifiedSelect<Record1<T>> all(Field<T>... fields)
```
Create an ALL quantified select to be used in quantified comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects will render a subselect unnesting the array.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

any
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <R extends Record> QuantifiedSelect<R> any(Select<R> select)
```
Create an ANY quantified select to be used in quantified comparison predicate expressions.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

any
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> QuantifiedSelect<Record1<T>> any(T... array)
```
Create an ANY quantified select to be used in quantified comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects will render a subselect unnesting the array.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

any
```
@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES})
public static <T> QuantifiedSelect<Record1<T>> any(Field<T[]> array)
```
Create an ANY quantified select to be used in quantified comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects will render a subselect unnesting the array.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

any
```
@Support
@SafeVarargs
public static <T> QuantifiedSelect<Record1<T>> any(Field<T>... fields)
```
Create an ANY quantified select to be used in quantified comparison predicate expressions.
This is natively supported by SQLDialect.POSTGRES. Other dialects will render a subselect unnesting the array.

See Also:

Field.equal(QuantifiedSelect), Field.notEqual(QuantifiedSelect), Field.greaterThan(QuantifiedSelect), Field.greaterOrEqual(QuantifiedSelect), Field.lessThan(QuantifiedSelect), Field.lessOrEqual(QuantifiedSelect), Field.like(QuantifiedSelect)

grant

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
public static GrantOnStep grant(Privilege privilege)

Grant a privilege on table to user or role.

Example:

 import static org.jooq.impl.DSL.*;

 grant(privilege)
   .on(table)
   .to(user)
   .execute();

 grant(privilege)
   .on(table)
   .to(role)
   .execute();

See Also:: grant(Collection)

grant

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
public static GrantOnStep grant(Privilege... privileges)

Grant privileges on table to user or role.

Example:

 import static org.jooq.impl.DSL.*;

 grant(privilege)
   .on(table)
   .to(user)
   .execute();

 grant(privilege)
   .on(table)
   .to(role)
   .execute();

See Also:: grant(Collection)

grant

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
public static GrantOnStep grant(Collection<? extends Privilege> privileges)

Grant privileges on table to user or role.

Example:

 import static org.jooq.impl.DSL.*;

 grant(privileges)
   .on(table)
   .to(user)
   .execute();

 grant(privileges)
   .on(table)
   .to(role)
   .execute();

See Also:: grant(Privilege...)

revoke

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
public static RevokeOnStep revoke(Privilege privilege)

Revoke a privilege on table from user or role.

Example:

 import static org.jooq.impl.DSL.*;

 revoke(privilege)
   .on(table)
   .from(user)
   .execute();

 revoke(privilege)
   .on(table)
   .from(role)
   .execute();

See Also:: revoke(Collection)

revoke

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
public static RevokeOnStep revoke(Privilege... privileges)

Revoke privileges on table from user or role.

Example:

 import static org.jooq.impl.DSL.*;

 revoke(privilege)
   .on(table)
   .from(user)
   .execute();

 revoke(privilege)
   .on(table)
   .from(role)
   .execute();

See Also:: revoke(Collection)

revoke

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
public static RevokeOnStep revoke(Collection<? extends Privilege> privileges)

Revoke privileges on table from user or role.

Example:

 import static org.jooq.impl.DSL.*;

 revoke(privileges)
   .on(table)
   .from(user)
   .execute();

 revoke(privileges)
   .on(table)
   .from(role)
   .execute();

See Also:: revoke(Privilege...)

revokeGrantOptionFor

@Support({AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
public static RevokeOnStep revokeGrantOptionFor(Privilege privilege)

Revoke grant option for a privilege on a table from user or role.

revokeGrantOptionFor

@Support({AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
public static RevokeOnStep revokeGrantOptionFor(Privilege... privileges)

Revoke grant option for some privileges on a table from user or role.

revokeGrantOptionFor

@Support({AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
public static RevokeOnStep revokeGrantOptionFor(Collection<? extends Privilege> privileges)

Revoke grant option for some privileges on a table from user or role.

collation

@Support({AURORA_MYSQL,AURORA_POSTGRES,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER})
public static Collation collation(String collation)

Create a collation by its unqualified name.

collation

@Support({AURORA_MYSQL,AURORA_POSTGRES,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER})
public static Collation collation(Name collation)

Create a collation by its qualified name.

characterSet

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL})
public static CharacterSet characterSet(String characterSet)

Create a character set by its unqualified name.

characterSet

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL})
public static CharacterSet characterSet(Name characterSet)

Create a character set by its qualified name.

privilege
```
@PlainSQL
@Support
public static Privilege privilege(String privilege)
```
Create a new privilege reference.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

user

@Support
public static User user(String name)

Create a new user reference.

See Also:: user(Name)

user

@Support
public static User user(Name name)

Create a new user reference.

role

@Support
public static Role role(String name)

Create a new role reference.

See Also:: role(Name)

role

@Support
public static Role role(Name name)

Create a new role reference.

table
```
@Support
public static <R extends Record> Table<R> table(Select<R> select)
```
A synonym for TableLike.asTable(), which might look a bit more fluent like this, to some users.

See Also:

TableLike.asTable()

table
```
@Support
public static <R extends Record> Table<R> table(Result<R> result)
```
Use a previously obtained result as a new Table that can be used in SQL statements through values(RowN...).

See Also:

values(RowN...)

table

@Support
public static <R extends Record> Table<R> table(R record)

Use a previously obtained record as a new Table

table

@Support
public static <R extends Record> Table<R> table(R... records)

Use a previously obtained set of records as a new Table

table

@Support
public static Table<?> table(Collection<?> list)

A synonym for unnest(Collection).

See Also:: unnest(Collection)

table

@Support
public static Table<?> table(Object[] array)

A synonym for unnest(Object[]).

See Also:: unnest(Object[])

table

@Support(ORACLE)
@Pro
public static Table<?> table(ArrayRecord<?> array)

A synonym for unnest(ArrayRecord).

See Also:: unnest(ArrayRecord)

table

@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES})
public static Table<?> table(Field<?> cursor)

A synonym for unnest(Field).

See Also:: unnest(Field)

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

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

unnest
```
@Support(ORACLE)
@Pro
public static Table<?> unnest(ArrayRecord<?> array)
```
Create a table from an array of values.
This wraps the argument array in a TABLE function for Oracle. Currently, only Oracle knows typed arrays

unnest
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES})
public static Table<?> unnest(Field<?> cursor)
```
Create a table from a field.
The supplied field can have any of these types:
- Result: For CURSOR or REF CURSOR fields, typically fetched from stored functions or from nested tables
- ArrayRecord: For Oracle-style VARRAY types.
- Object[]: Array types, for other RDBMS's ARRAY types (e.g. H2, HSQLDB, and Postgres)
- Object: Any other type that jOOQ will try to convert in an array first, before converting that array into a table
This functionality has only limited scope when used in H2, as ARRAY types involved with stored functions can only be of type Object[]. Such arrays are converted into VARCHAR arrays by jOOQ.
In all dialects where arrays are not supported, unnesting of arrays is emulated using several UNION ALL connected subqueries.

dual
```
@Support
public static Table<Record> dual()
```
The DUAL table to be used for syntactic completeness.
In general, jOOQ will generate a DUAL table (or any equivalent construct, see below), if this is needed syntactically in generated SQL. You may still wish to explicitly use a DUAL construct in jOOQ code for various reasons. This DUAL table will always contain a single record with a single varchar(1) value:
```
 +-------+
 | DUMMY |
 +-------+
 | X     |
 +-------+
 
```

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(int from,
                                                     int to)

A table function generating a series of values from from to to (inclusive).

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(int from,
                                                     Field<Integer> to)

A table function generating a series of values from from to to (inclusive).

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(Field<Integer> from,
                                                     int to)

A table function generating a series of values from from to to (inclusive).

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(Field<Integer> from,
                                                     Field<Integer> to)

A table function generating a series of values from from to to (inclusive).

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL - 1 FROM DUAL CONNECT BY a + LEVEL - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(int from,
                                                     int to,
                                                     int step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c- 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(int from,
                                                     Field<Integer> to,
                                                     int step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(Field<Integer> from,
                                                     int to,
                                                     int step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(Field<Integer> from,
                                                     Field<Integer> to,
                                                     int step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(int from,
                                                     int to,
                                                     Field<Integer> step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c- 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(int from,
                                                     Field<Integer> to,
                                                     Field<Integer> step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(Field<Integer> from,
                                                     int to,
                                                     Field<Integer> step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

generateSeries

@Support({AURORA_POSTGRES,CUBRID,ORACLE,POSTGRES})
public static Table<Record1<Integer>> generateSeries(Field<Integer> from,
                                                     Field<Integer> to,
                                                     Field<Integer> step)

A table function generating a series of values from from to to (inclusive), increasing values by step.

This function is inspired by PostgreSQL's GENERATE_SERIES(from, to, step) function. Other SQL dialects may be capable of emulating this behaviour, e.g. Oracle:

 -- PostgreSQL
 SELECT * FROM GENERATE_SERIES(a, b, c)

 -- Oracle
 SELECT * FROM (SELECT a + LEVEL * c - 1 FROM DUAL CONNECT BY a + LEVEL * c - 1 <= b)

lateral

@Support({AURORA_POSTGRES,DB2,MYSQL_8_0,ORACLE12C,POSTGRES_9_3})
public static <R extends Record> Table<R> lateral(TableLike<R> table)

Create a LATERAL joined table.

Example:

 SELECT *
 FROM employees e,
      LATERAL(SELECT * FROM departments d
              WHERE e.department_id = d.department_id);

rowsFrom

@Support({AURORA_POSTGRES,POSTGRES})
public static Table<Record> rowsFrom(Table<?>... tables)

Create a ROWS FROM (tables...) expression.

Example:

 SELECT *
 FROM ROWS FROM (function1('a', 'b'), function2('c', 'd'));

This allows for full outer joining several table-valued functions on the row number of each function's produced rows.

keyword
```
@Support
public static Keyword keyword(String keyword)
```
Create a SQL keyword.
A Keyword is a QueryPart that renders a SQL keyword according to the settings specified in Settings.getRenderKeywordCase(). It can be embedded in other plain SQL QueryParts as shown in this example:
```
 Condition c = condition("{0} {1} {2} {3} {4}",
     value1, keyword("between")
     value2, keyword("and")
     value3
 );
 
```

name
```
@Support
public static Name name(String unqualifiedName)
```
Create a new SQL identifier using an unqualified name.
Use this method to construct syntax-safe, SQL-injection-safe SQL identifiers for use in plain SQL where QueryPart objects are accepted. For instance, this can be used with any of these methods:
An example:
```
 // This unqualified name here
 name("book");

 // ... will render this SQL by default, using the SQL Server dialect
 [book].[title]
 
```
Parameters:

unqualifiedName - The SQL identifier's unqualified name

Returns:

A QueryPart that will render the SQL identifier

name
```
@Support
public static Name name(String... qualifiedName)
```
Create a new SQL identifier using a qualified name.
Use this method to construct syntax-safe, SQL-injection-safe SQL identifiers for use in plain SQL where QueryPart objects are accepted. For instance, this can be used with any of these methods:
An example:
```
 // This qualified name here
 name("book", "title");

 // ... will render this SQL by default, using the SQL Server dialect
 [book].[title]
 
```
Parameters:

qualifiedName - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

name
```
@Support
public static Name name(Name... nameParts)
```
Create a new SQL identifier using a qualified name.
Unlike other name(String...) constructors, this one constructs a name from its argument Name.unqualifiedName() parts, retaining the quoted flag, to construct a new name.
Use this method to construct syntax-safe, SQL-injection-safe SQL identifiers for use in plain SQL where QueryPart objects are accepted. For instance, this can be used with any of these methods:
An example:
```
 // This qualified name here
 name(quotedName("book"), unquotedName("title"));

 // ... will render this SQL by default, using the SQL Server dialect
 [book].title
 
```
Parameters:

nameParts - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

name
```
@Support
public static Name name(Collection<String> qualifiedName)
```
Create a new SQL identifier using a qualified name.
Use this method to construct syntax-safe, SQL-injection-safe SQL identifiers for use in plain SQL where QueryPart objects are accepted. For instance, this can be used with any of these methods:
An example:
```
 // This qualified name here
 name("book", "title");

 // ... will render this SQL by default, using the SQL Server dialect
 [book].[title]
 
```
Parameters:

qualifiedName - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

quotedName
```
@Support
public static Name quotedName(String unqualifiedName)
```
Create a new SQL identifier using an unqualified, quoted name.
This works like name(String...), except that generated identifiers will be guaranteed to be quoted in databases that support quoted identifiers.

Parameters:

unqualifiedName - The SQL identifier's unqualified name

Returns:

A QueryPart that will render the SQL identifier

quotedName
```
@Support
public static Name quotedName(String... qualifiedName)
```
Create a new SQL identifier using a qualified, quoted name.
This works like name(String...), except that generated identifiers will be guaranteed to be quoted in databases that support quoted identifiers.

Parameters:

qualifiedName - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

quotedName
```
@Support
public static Name quotedName(Collection<String> qualifiedName)
```
Create a new SQL identifier using a qualified, quoted name.
This works like name(Collection), except that generated identifiers will be guaranteed to be quoted in databases that support quoted identifiers.

Parameters:

qualifiedName - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

unquotedName
```
@Support
public static Name unquotedName(String unqualifiedName)
```
Create a new SQL identifier using an unqualified, quoted name.
This works like name(String...), except that generated identifiers will be guaranteed to be quoted in databases that support quoted identifiers.

Parameters:

unqualifiedName - The SQL identifier's unqualified name

Returns:

A QueryPart that will render the SQL identifier

unquotedName
```
@Support
public static Name unquotedName(String... qualifiedName)
```
Create a new SQL identifier using a qualified, quoted name.
This works like name(String...), except that generated identifiers will be guaranteed to be quoted in databases that support quoted identifiers.

Parameters:

qualifiedName - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

unquotedName
```
@Support
public static Name unquotedName(Collection<String> qualifiedName)
```
Create a new SQL identifier using a qualified, quoted name.
This works like name(Collection), except that generated identifiers will be guaranteed to be quoted in databases that support quoted identifiers.

Parameters:

qualifiedName - The SQL identifier's qualified name parts

Returns:

A QueryPart that will render the SQL identifier

list
```
@Support
public static QueryPart list(QueryPart... parts)
```
Compose a list of QueryParts into a new QueryPart, with individual parts being comma-separated.

list
```
@Support
public static QueryPart list(Collection<? extends QueryPart> parts)
```
Compose a list of QueryParts into a new QueryPart, with individual parts being comma-separated.

defaultValue
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Object> defaultValue()
```
Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.
While the DEFAULT keyword works with all data types, you may still prefer to associate a Field type with your DEFAULT value. In that case, use defaultValue(Class) or defaultValue(DataType) instead.
This is an alias for default_().

See Also:

default_()

defaultValue

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> Field<T> defaultValue(Class<T> type)

Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.

This is an alias for default_(Class).

See Also:: default_(Class)

defaultValue

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> Field<T> defaultValue(DataType<T> type)

Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.

This is an alias for default_(DataType).

See Also:: default_(DataType)

defaultValue

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> Field<T> defaultValue(Field<T> field)

Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.

This is an alias for default_(Field).

See Also:: default_(Field)

default_
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Object> default_()
```
Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.
While the DEFAULT keyword works with all data types, you may still prefer to associate a Field type with your DEFAULT value. In that case, use defaultValue(Class) or defaultValue(DataType) instead.

default_

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> Field<T> default_(Class<T> type)

Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.

default_

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> Field<T> default_(DataType<T> type)

Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.

default_

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,H2,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T> Field<T> default_(Field<T> field)

Create a DEFAULT keyword for use with INSERT, UPDATE, or MERGE statements.

schemaByName
```
@Deprecated
@Support
public static Schema schemaByName(String name)
```
Deprecated.
- [#3843] - 3.6.0 - use schema(Name) instead
Create a qualified schema, given its schema name.
This constructs a schema reference given the schema's qualified name.
Example:
```
 // This schema...
 schemaByName("MY_SCHEMA");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA]
 
```
Parameters:

name - The schema's reference name.

Returns:

A schema referenced by name

catalog

@Support
public static Catalog catalog(Name name)

Create a qualified catalog, given its catalog name.

This constructs a catalog reference given the catalog's qualified name.

Example:

 // This catalog...
 catalog(name("MY_CATALOG"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_CATALOG]

schema

@Support
public static Schema schema(Name name)

Create a qualified schema, given its schema name.

This constructs a schema reference given the schema's qualified name.

Example:

 // This schema...
 schema(name("MY_CATALOG", "MY_SCHEMA"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_CATALOG].[MY_SCHEMA]

sequenceByName

@Deprecated
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static Sequence<BigInteger> sequenceByName(String... qualifiedName)

Deprecated.

- [#3843] - 3.6.0 - use sequence(Name) instead

Create a qualified sequence, given its sequence name.

This constructs a sequence reference given the sequence's qualified name.

Example:

 // This sequence...
 sequenceByName("MY_SCHEMA", "MY_SEQUENCE");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_SEQUENCE]

Parameters:: qualifiedName - The various parts making up your sequence's reference name.
Returns:: A sequence referenced by sequenceName

sequenceByName

@Deprecated
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> Sequence<T> sequenceByName(Class<T> type,
                                                            String... qualifiedName)

Deprecated.

- [#3843] - 3.6.0 - use sequence(Name, Class) instead

Create a qualified sequence, given its sequence name.

This constructs a sequence reference given the sequence's qualified name.

Example:

 // This sequence...
 sequenceByName("MY_SCHEMA", "MY_SEQUENCE");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_SEQUENCE]

Parameters:: qualifiedName - The various parts making up your sequence's reference name.; type - The type of the returned field
Returns:: A sequence referenced by sequenceName

sequenceByName

@Deprecated
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> Sequence<T> sequenceByName(DataType<T> type,
                                                            String... qualifiedName)

Deprecated.

- [#3843] - 3.6.0 - use sequence(Name, DataType) instead

Create a qualified sequence, given its sequence name.

This constructs a sequence reference given the sequence's qualified name.

Example:

 // This sequence...
 sequenceByName("MY_SCHEMA", "MY_SEQUENCE");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_SEQUENCE]

Parameters:: qualifiedName - The various parts making up your sequence's reference name.; type - The type of the returned field
Returns:: A sequence referenced by sequenceName

sequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static Sequence<BigInteger> sequence(Name name)

Create a qualified sequence, given its sequence name.

This constructs a sequence reference given the sequence's qualified name.

Example:

 // This sequence...
 sequence(name("MY_SCHEMA", "MY_SEQUENCE"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_SEQUENCE]

sequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> Sequence<T> sequence(Name name,
                                                      Class<T> type)

Create a qualified sequence, given its sequence name.

This constructs a sequence reference given the sequence's qualified name.

Example:

 // This sequence...
 sequence(name("MY_SCHEMA", "MY_SEQUENCE"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_SEQUENCE]

sequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
public static <T extends Number> Sequence<T> sequence(Name name,
                                                      DataType<T> type)

Create a qualified sequence, given its sequence name.

This constructs a sequence reference given the sequence's qualified name.

Example:

 // This sequence...
 sequence(name("MY_SCHEMA", "MY_SEQUENCE"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_SEQUENCE]

tableByName
```
@Deprecated
@Support
public static Table<Record> tableByName(String... qualifiedName)
```
Deprecated.
- [#3843] - 3.6.0 - use table(Name) instead
Create a qualified table, given its table name.
This constructs a table reference given the table's qualified name. jOOQ
Example:
```
 // This table...
 tableByName("MY_SCHEMA", "MY_TABLE");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE]
 
```
Parameters:

qualifiedName - The various parts making up your table's reference name.

Returns:

A table referenced by tableName

table
```
@Support
public static Table<Record> table(Name name)
```
Create a qualified table, given its table name.
This constructs a table reference given the table's qualified name. jOOQ
Example:
```
 // This table...
 tableByName("MY_SCHEMA", "MY_TABLE");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE]
 
```
The returned table does not know its field references, i.e. TableLike.fields() returns an empty array.

table

@Support
public static Table<Record> table(Name name,
                                  Comment comment)

Create a qualified table, given its table name.

This constructs a table reference given the table's qualified name. jOOQ

Example:

 // This table...
 tableByName("MY_SCHEMA", "MY_TABLE");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE]

The returned table does not know its field references, i.e. TableLike.fields() returns an empty array.

fieldByName

@Deprecated
@Support
public static Field<Object> fieldByName(String... qualifiedName)

Deprecated.

- [#3843] - 3.6.0 - use field(Name) instead

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 fieldByName("MY_SCHEMA", "MY_TABLE", "MY_FIELD");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, fieldByName("TITLE")))
       .from(tableByName("T_BOOK"))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

Parameters:: qualifiedName - The various parts making up your field's reference name.
Returns:: A field referenced by fieldName

fieldByName

@Deprecated
@Support
public static <T> Field<T> fieldByName(Class<T> type,
                                       String... qualifiedName)

Deprecated.

- [#3843] - 3.6.0 - use field(Name, Class) instead

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 fieldByName("MY_SCHEMA", "MY_TABLE", "MY_FIELD");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, fieldByName("TITLE")))
       .from(tableByName("T_BOOK"))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

Parameters:: qualifiedName - The various parts making up your field's reference name.; type - The type of the returned field
Returns:: A field referenced by fieldName

fieldByName

@Deprecated
@Support
public static <T> Field<T> fieldByName(DataType<T> type,
                                       String... qualifiedName)

Deprecated.

- [#3843] - 3.6.0 - use field(Name, DataType) instead

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 fieldByName("MY_SCHEMA", "MY_TABLE", "MY_FIELD");

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, fieldByName("TITLE")))
       .from(tableByName("T_BOOK"))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

Parameters:: qualifiedName - The various parts making up your field's reference name.; type - The type of the returned field
Returns:: A field referenced by fieldName

field

@Support
public static Field<Object> field(Name name)

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, field(name("TITLE"))))
       .from(table(name("T_BOOK")))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

field

@Support
public static <T> Field<T> field(Name name,
                                 Class<T> type)

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, field(name("TITLE"))))
       .from(table(name("T_BOOK")))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

field

@Support
public static <T> Field<T> field(Name name,
                                 DataType<T> type)

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, field(name("TITLE"))))
       .from(table(name("T_BOOK")))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

field

@Support
public static <T> Field<T> field(Name name,
                                 DataType<T> type,
                                 Comment comment)

Create a qualified field, given its (qualified) field name.

This constructs a field reference given the field's qualified name. jOOQ

Example:

 // This field...
 field(name("MY_SCHEMA", "MY_TABLE", "MY_FIELD"));

 // ... will render this SQL by default, using the SQL Server dialect
 [MY_SCHEMA].[MY_TABLE].[MY_FIELD]

Another example:

 create.select(field("length({1})", Integer.class, field(name("TITLE"))))
       .from(table(name("T_BOOK")))
       .fetch();

 // ... will execute this SQL on SQL Server:
 select length([TITLE]) from [T_BOOK]

index

@Support
public static Index index(Name name)

Create a qualified index reference by name.

queries
```
@Support
public static Queries queries(Query... queries)
```
Wrap a collection of queries.

See Also:

DSLContext.queries(Query...)

queries

@Support
public static Queries queries(Collection<? extends Query> queries)

Wrap a collection of queries.

See Also:: DSLContext.queries(Collection)

begin

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
public static Block begin(Statement... statements)

Wrap a collection of statements in an anonymous procedural block.

See Also:: DSLContext.begin(Statement...)

begin

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
public static Block begin(Collection<? extends Statement> statements)

Wrap a collection of statements in an anonymous procedural block.

See Also:: DSLContext.begin(Collection)

statements

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
@Pro
public static Block statements(Statement... statements)

Wrap a collection of statements in an anonymous procedural block that does not wrap in BEGIN .. END;, unless explicitly needed.

See Also:: DSLContext.statements(Statement...)

statements

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
@Pro
public static Block statements(Collection<? extends Statement> statements)

Wrap a collection of statements in an anonymous procedural block that does not wrap in BEGIN .. END;, unless explicitly needed.

See Also:: DSLContext.statements(Collection)

var

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Variable<T> var(String name,
                                  DataType<T> type)

Create a local variable reference for use in procedural code.

See Also:: begin(Statement...)

var

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Variable<T> var(Name name,
                                  DataType<T> type)

Create a local variable reference for use in procedural code.

See Also:: begin(Statement...)

variable

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Variable<T> variable(String name,
                                       DataType<T> type)

A synonym for var(Name, DataType) to be used in Scala and Groovy, where var is a reserved keyword.

See Also:: val(Object), begin(Statement...)

variable

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Variable<T> variable(Name name,
                                       DataType<T> type)

A synonym for var(Name, DataType) to be used in Scala and Groovy, where var is a reserved keyword.

See Also:: val(Object), begin(Statement...)

declare
```
@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Declaration<T> declare(Variable<T> variable)
```
Create a local variable declaration for use in procedural code.
Declarations can be inlined in any statement Block as is supported by databases like SQLDialect.MYSQL or SQLDialect.SQLSERVER. If the underlying database requires a dedicated DECLARE section, the section will be generated automatically and if needed, a nested Block is generated.

See Also:

begin(Statement...)

execute
```
@Support(POSTGRES)
@Pro
public static Statement execute(String sql)
```
Execute a statement dynamically from within procedural code.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
```
 BEGIN
   EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
 END;
 
```

execute
```
@Support(POSTGRES)
@Pro
public static Statement execute(Field<String> sql)
```
Execute a statement dynamically from within procedural code.
Many dialects support some way of running procedural and SQL statements dynamically from within procedural code. For example, in Oracle, this syntax is required to run DDL statements from PL/SQL:
```
 BEGIN
   EXECUTE IMMEDIATE 'CREATE TABLE x (i INT)';
 END;
 
```

if_

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static IfThenStep if_(Condition condition)

Create an IF statement for use in procedural code.

See Also:: begin(Statement...)

while_

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static LoopStep while_(Condition condition)

Create a WHILE loop for use in procedural code.

See Also:: begin(Statement...)

repeat

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static RepeatUntilStep repeat(Statement... statements)

Create a REPEAT loop for use in procedural code.

See Also:: begin(Statement...)

repeat

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static RepeatUntilStep repeat(Collection<? extends Statement> statements)

Create a REPEAT loop for use in procedural code.

See Also:: begin(Statement...)

for_

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> ForInStep<T> for_(Variable<T> index)

Create a FOR loop for use in procedural code.

See Also:: begin(Statement...)

loop

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Statement loop(Statement... statements)

Create a LOOP for use in procedural code.

See Also:: begin(Statement...)

loop

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Statement loop(Collection<? extends Statement> statements)

Create a LOOP for use in procedural code.

See Also:: begin(Statement...)

label

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Label label(String label)

Create a label reference for use in procedural code.

See Also:: begin(Statement...)

label

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Label label(Name label)

Create a label reference for use in procedural code.

See Also:: begin(Statement...)

goto_

@Support({DB2,ORACLE,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Statement goto_(Label label)

Create an GOTO statement for use in procedural code.

See Also:: begin(Statement...)

exit

@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static ExitWhenStep exit()

Create an EXIT statement for use in procedural code.

See Also:: begin(Statement...)

exit

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES})
@Pro
public static ExitWhenStep exit(Label label)

Create an EXIT statement for use in procedural code.

See Also:: begin(Statement...)

exitWhen

@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Statement exitWhen(Condition condition)

Create an EXIT statement for use in procedural code.

See Also:: begin(Statement...)

continue_

@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static ContinueWhenStep continue_()

Create an CONTINUE statement for use in procedural code.

See Also:: begin(Statement...)

continue_

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MYSQL,ORACLE,POSTGRES})
@Pro
public static ContinueWhenStep continue_(Label label)

Create an CONTINUE statement for use in procedural code.

See Also:: begin(Statement...)

continueWhen

@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static Statement continueWhen(Condition condition)

Create an CONTINUE statement for use in procedural code.

See Also:: begin(Statement...)

link

@Support(ORACLE)
@Pro
public static Link link(String name)

Create a database link reference.

link

@Support(ORACLE)
@Pro
public static Link link(String name,
                        Schema schema)

Create a database link reference.

link

@Support(ORACLE)
@Pro
public static Link link(Name name)

Create a database link reference.

sql
```
@Support
@PlainSQL
public static SQL sql(String sql)
```
A custom SQL clause that can render arbitrary expressions.
A plain SQL QueryPart is a QueryPart that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

Returns:

A query part wrapping the plain SQL

See Also:

SQL

sql
```
@Support
@PlainSQL
public static SQL sql(String sql,
                      QueryPart... parts)
```
A custom SQL clause that can render arbitrary expressions.
A plain SQL QueryPart is a QueryPart that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL.
This overload takes a set of QueryPart arguments which are replaced into the SQL string template at the appropriate index. Example:
```
 // Argument QueryParts are replaced into the SQL string at the appropriate index
 sql("select {0}, {1} from {2}", TABLE.COL1, TABLE.COL2, TABLE);

 // Bind variables are supported as well, for backwards compatibility
 sql("select col1, col2 from table where col1 = ?", val(1));
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A query part wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

sql
```
@Support
@PlainSQL
public static SQL sql(String sql,
                      Object... bindings)
```
A custom SQL clause that can render arbitrary expressions.
A plain SQL QueryPart is a QueryPart that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL. There must be as many bind variables contained in the SQL, as passed in the bindings parameter
This overload takes a set of bind value arguments which are replaced our bound into the SQL string template at the appropriate index. Example:
```
 sql("select col1, col2 from table where col1 = ?", 1);
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A query part wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

queryPart
```
@Deprecated
@Support
@PlainSQL
public static QueryPart queryPart(String sql)
```
Deprecated.
- 3.6.0 - [#3854] - Use sql(String) instead

A custom SQL clause that can render arbitrary expressions.
A plain SQL QueryPart is a QueryPart that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

Returns:

A query part wrapping the plain SQL

See Also:

SQL

queryPart
```
@Deprecated
@Support
@PlainSQL
public static QueryPart queryPart(String sql,
                                  QueryPart... parts)
```
Deprecated.
- 3.6.0 - [#3854] - Use sql(String, QueryPart...) instead

A custom SQL clause that can render arbitrary expressions.
A plain SQL QueryPart is a QueryPart that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A query part wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

queryPart
```
@Deprecated
@Support
@PlainSQL
public static QueryPart queryPart(String sql,
                                  Object... bindings)
```
Deprecated.
- 3.6.0 - [#3854] - Use sql(String, Object...) instead

A custom SQL clause that can render arbitrary expressions.
A plain SQL QueryPart is a QueryPart that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL. There must be as many bind variables contained in the SQL, as passed in the bindings parameter
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

Returns:

A query part wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

query
```
@Support
@PlainSQL
public static RowCountQuery query(SQL sql)
```
Create a new query holding plain SQL. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "SET SCHEMA 'abc'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query
```
@Support
@PlainSQL
public static RowCountQuery query(String sql)
```
Create a new query holding plain SQL. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "SET SCHEMA 'abc'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query
```
@Support
@PlainSQL
public static RowCountQuery query(String sql,
                                  Object... bindings)
```
Create a new query holding plain SQL. There must be as many bind variables contained in the SQL, as passed in the bindings parameter.
Example:
```
 String sql = "SET SCHEMA 'abc'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

A query wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

query
```
@Support
@PlainSQL
public static RowCountQuery query(String sql,
                                  QueryPart... parts)
```
Create a new query holding plain SQL.
Unlike query(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 query("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will render this SQL by default, using Oracle SQL dialect
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A query wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

resultQuery

@Support
@PlainSQL
public static ResultQuery<Record> resultQuery(SQL sql)

Create a new query holding plain SQL.

There must not be any bind variables contained in the SQL

Use this method, when you want to take advantage of the many ways to fetch results in jOOQ, using ResultQuery. Some examples:

`ResultQuery.fetchLazy()`	Open a cursor and fetch records one by one
`ResultQuery.fetchInto(Class)`	Fetch records into a custom POJO (optionally annotated with JPA annotations)
`ResultQuery.fetchInto(RecordHandler)`	Fetch records into a custom callback (similar to Spring's RowMapper)

Example (Postgres):

 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";

Example (SQLite):

 String sql = "pragma table_info('my_table')";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:: sql - The SQL
Returns:: An executable query
See Also:: SQL

resultQuery

@Support
@PlainSQL
public static ResultQuery<Record> resultQuery(String sql)

Create a new query holding plain SQL.

There must not be any bind variables contained in the SQL

Use this method, when you want to take advantage of the many ways to fetch results in jOOQ, using ResultQuery. Some examples:

`ResultQuery.fetchLazy()`	Open a cursor and fetch records one by one
`ResultQuery.fetchInto(Class)`	Fetch records into a custom POJO (optionally annotated with JPA annotations)
`ResultQuery.fetchInto(RecordHandler)`	Fetch records into a custom callback (similar to Spring's RowMapper)

Example (Postgres):

 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";

Example (SQLite):

 String sql = "pragma table_info('my_table')";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:: sql - The SQL
Returns:: An executable query
See Also:: SQL

resultQuery

@Support
@PlainSQL
public static ResultQuery<Record> resultQuery(String sql,
                                              Object... bindings)

Create a new query holding plain SQL.

There must be as many bind variables contained in the SQL, as passed in the bindings parameter

Use this method, when you want to take advantage of the many ways to fetch results in jOOQ, using ResultQuery. Some examples:

`ResultQuery.fetchLazy()`	Open a cursor and fetch records one by one
`ResultQuery.fetchInto(Class)`	Fetch records into a custom POJO (optionally annotated with JPA annotations)
`ResultQuery.fetchInto(RecordHandler)`	Fetch records into a custom callback (similar to Spring's RowMapper)

Example (Postgres):

 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";

Example (SQLite):

 String sql = "pragma table_info('my_table')";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:: sql - The SQL; bindings - The bindings
Returns:: A query wrapping the plain SQL
See Also:: SQL, sql(String, Object...)

resultQuery
```
@Support
@PlainSQL
public static ResultQuery<Record> resultQuery(String sql,
                                              QueryPart... parts)
```
Create a new query holding plain SQL.
Unlike resultQuery(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will render this SQL by default, using Oracle SQL dialect
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A query wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

table
```
@Support
@PlainSQL
public static Table<Record> table(SQL sql)
```
A custom SQL clause that can render arbitrary table expressions.
A plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
Example
```
 String sql = "SELECT * FROM USER_TABLES WHERE OWNER = 'MY_SCHEMA'";
 
```
The returned table does not know its field references, i.e. TableLike.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A table wrapping the plain SQL

See Also:

SQL

table
```
@Support
@PlainSQL
public static Table<Record> table(String sql)
```
A custom SQL clause that can render arbitrary table expressions.
A plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
Example
```
 String sql = "SELECT * FROM USER_TABLES WHERE OWNER = 'MY_SCHEMA'";
 
```
The returned table does not know its field references, i.e. TableLike.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A table wrapping the plain SQL

See Also:

SQL

table
```
@Support
@PlainSQL
public static Table<Record> table(String sql,
                                  Object... bindings)
```
A custom SQL clause that can render arbitrary table expressions.
A plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas. There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example
```
 String sql = "SELECT * FROM USER_TABLES WHERE OWNER = ?";
 Object[] bindings = new Object[] { "MY_SCHEMA" };
 
```
The returned table does not know its field references, i.e. TableLike.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A table wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

table
```
@Support
@PlainSQL
public static Table<Record> table(String sql,
                                  QueryPart... parts)
```
A custom SQL clause that can render arbitrary table expressions.
A plain SQL table is a table that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex, but static subqueries or tables from different schemas.
Example
```
 String sql = "SELECT * FROM USER_TABLES WHERE {0}";
 QueryPart[] parts = new QueryPart[] { USER_TABLES.OWNER.equal("MY_SCHEMA") };
 
```
The returned table does not know its field references, i.e. TableLike.fields() returns an empty array.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A table wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

sequence
```
@Deprecated
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE})
@PlainSQL
public static Sequence<BigInteger> sequence(String sql)
```
Deprecated.
- 3.10 - [#6162] - Use sequence(Name) instead.

Create a "plain SQL" sequence.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

Returns:

A field wrapping the plain SQL

See Also:

SQL

sequence
```
@Deprecated
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE})
@PlainSQL
public static <T extends Number> Sequence<T> sequence(String sql,
                                                      Class<T> type)
```
Deprecated.
- 3.10 - [#6162] - Use sequence(Name, Class) instead.

Create a "plain SQL" sequence.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

type - The field type

Returns:

A field wrapping the plain SQL

See Also:

SQL

sequence
```
@Deprecated
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE})
@PlainSQL
public static <T extends Number> Sequence<T> sequence(String sql,
                                                      DataType<T> type)
```
Deprecated.
- 3.10 - [#6162] - Use sequence(Name, DataType) instead.

Create a "plain SQL" sequence.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

type - The field type

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static Field<Object> field(SQL sql)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "DECODE(MY_FIELD, 1, 100, 200)";
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static Field<Object> field(String sql)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "DECODE(MY_FIELD, 1, 100, 200)";
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static Field<Object> field(String sql,
                                  Object... bindings)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
```
 String sql = "DECODE(MY_FIELD, ?, ?, ?)";
 Object[] bindings = new Object[] { 1, 100, 200 };
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings for the field

Returns:

A field wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

field
```
@Support
@PlainSQL
public static <T> Field<T> field(SQL sql,
                                 Class<T> type)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "DECODE(MY_FIELD, 1, 100, 200)";
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

type - The field type

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static <T> Field<T> field(String sql,
                                 Class<T> type)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "DECODE(MY_FIELD, 1, 100, 200)";
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

type - The field type

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static <T> Field<T> field(String sql,
                                 Class<T> type,
                                 Object... bindings)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
```
 String sql = "DECODE(MY_FIELD, ?, ?, ?)";
 Object[] bindings = new Object[] { 1, 100, 200 };
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

type - The field type

bindings - The bindings for the field

Returns:

A field wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

field
```
@Support
@PlainSQL
public static <T> Field<T> field(SQL sql,
                                 DataType<T> type)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "DECODE(MY_FIELD, 1, 100, 200)";
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

type - The field type

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static <T> Field<T> field(String sql,
                                 DataType<T> type)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "DECODE(MY_FIELD, 1, 100, 200)";
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

type - The field type

Returns:

A field wrapping the plain SQL

See Also:

SQL

field
```
@Support
@PlainSQL
public static <T> Field<T> field(String sql,
                                 DataType<T> type,
                                 Object... bindings)
```
Create a "plain SQL" field.
A PlainSQLField is a field that can contain user-defined plain SQL, because sometimes it is easier to express things directly in SQL, for instance complex proprietary functions. There must be as many binding variables contained in the SQL, as passed in the bindings parameter
Example:
```
 String sql = "DECODE(MY_FIELD, ?, ?, ?)";
 Object[] bindings = new Object[] { 1, 100, 200 };
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

type - The field type

bindings - The bindings for the field

Returns:

A field wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

field
```
@Support
@PlainSQL
public static <T> Field<T> field(String sql,
                                 DataType<T> type,
                                 QueryPart... parts)
```
Create a "plain SQL" field.
This is useful for constructing more complex SQL syntax elements wherever Field types are expected. An example for this is MySQL's GROUP_CONCAT aggregate function, which has MySQL-specific keywords that are hard to reflect in jOOQ's DSL:
```
 GROUP_CONCAT([DISTINCT] expr [,expr ...]
       [ORDER BY {unsigned_integer | col_name | expr}
           [ASC | DESC] [,col_name ...]]
       [SEPARATOR str_val])
       
```
The above MySQL function can be expressed as such:
```
 field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use name(String...) and similar methods
Parameters:

sql - The SQL

type - The field type

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A field wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

field
```
@Support
@PlainSQL
public static Field<Object> field(String sql,
                                  QueryPart... parts)
```
A custom SQL clause that can render arbitrary SQL elements.
This is useful for constructing more complex SQL syntax elements wherever Field types are expected. An example for this is MySQL's GROUP_CONCAT aggregate function, which has MySQL-specific keywords that are hard to reflect in jOOQ's DSL:
```
 GROUP_CONCAT([DISTINCT] expr [,expr ...]
       [ORDER BY {unsigned_integer | col_name | expr}
           [ASC | DESC] [,col_name ...]]
       [SEPARATOR str_val])
       
```
The above MySQL function can be expressed as such:
```
 field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A field wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

field
```
@Support
@PlainSQL
public static <T> Field<T> field(String sql,
                                 Class<T> type,
                                 QueryPart... parts)
```
A custom SQL clause that can render arbitrary SQL elements.
This is useful for constructing more complex SQL syntax elements wherever Field types are expected. An example for this is MySQL's GROUP_CONCAT aggregate function, which has MySQL-specific keywords that are hard to reflect in jOOQ's DSL:
```
 GROUP_CONCAT([DISTINCT] expr [,expr ...]
       [ORDER BY {unsigned_integer | col_name | expr}
           [ASC | DESC] [,col_name ...]]
       [SEPARATOR str_val])
       
```
The above MySQL function can be expressed as such:
```
 field("GROUP_CONCAT(DISTINCT {0} ORDER BY {1} ASC SEPARATOR '-')", expr1, expr2);
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

type - The field type

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A field wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

function
```
@Support
@PlainSQL
public static <T> 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.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

name - The function name (without parentheses)

type - The function return type

arguments - The function arguments

See Also:

SQL

function
```
@Support
@PlainSQL
public static <T> 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.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

name - The function name (without parentheses)

type - The function return type

arguments - The function arguments

See Also:

SQL

function

@Support
public static <T> 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.

Parameters:: name - The function name (possibly qualified); type - The function return type; arguments - The function arguments

function

@Support
public static <T> 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.

Parameters:: name - The function name (possibly qualified); type - The function return type; arguments - The function arguments

condition
```
@Support
@PlainSQL
public static Condition condition(SQL sql)
```
Create a new condition holding plain SQL.
There must not be any bind variables contained in the SQL.
Example:
```
 String sql = "(X = 1 and Y = 2)";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A condition wrapping the plain SQL

See Also:

SQL

condition
```
@Support
@PlainSQL
public static Condition condition(String sql)
```
Create a new condition holding plain SQL.
There must not be any bind variables contained in the SQL.
Example:
```
 String sql = "(X = 1 and Y = 2)";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A condition wrapping the plain SQL

See Also:

SQL

condition
```
@Support
@PlainSQL
public static Condition condition(String sql,
                                  Object... bindings)
```
Create a new condition holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example:
```
 String sql = "(X = ? and Y = ?)";
 Object[] bindings = new Object[] { 1, 2 };
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

A condition wrapping the plain SQL

See Also:

SQL, sql(String, Object...)

condition
```
@Support
@PlainSQL
public static Condition condition(String sql,
                                  QueryPart... parts)
```
A custom SQL clause that can render arbitrary SQL elements.
This is useful for constructing more complex SQL syntax elements wherever Condition types are expected. An example for this are Postgres's various operators, some of which are missing in the jOOQ API. For instance, the "overlap" operator for arrays:
```
ARRAY[1,4,3] && ARRAY[2,1]
```
The above Postgres operator can be expressed as such:
```
 condition("{0} && {1}", array1, array2);
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use name(String...) and similar methods
Parameters:

sql - The SQL

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A condition wrapping the plain SQL

See Also:

SQL, sql(String, QueryPart...)

condition
```
@Support
public static Condition condition(Boolean value)
```
Create a condition from a boolean field.
Databases that support boolean data types can use boolean expressions as predicates or as columns interchangeably. This extends to any type of field, including functions. A Postgres example:
```
 select 1 where texteq('a', 'a');
 
```
Parameters:

value - The boolean expression.

Returns:

A condition wrapping the boolean expression

condition
```
@Support
public static Condition condition(Field<Boolean> field)
```
Create a condition from a boolean field.
Databases that support boolean data types can use boolean expressions as predicates or as columns interchangeably. This extends to any type of field, including functions. A Postgres example:
```
 select 1 where texteq('a', 'a');
 
```
Parameters:

field - The boolean expression.

Returns:

A condition wrapping the boolean expression

condition
```
@Support
public static Condition condition(Map<Field<?>,?> map)
```
Create a condition from a map.
The result is a condition generated from keys and values of the argument map, such that:
```
 key1 = value1 AND key2 = value2 AND ... AND keyN = valueN
 
```
Parameters:

map - A map containing keys and values to form predicates.

Returns:

A condition comparing keys with values.

condition
```
@Support
public static Condition condition(Record record)
```
Create a "Query By Example" (QBE) Condition from a Record .
This will take all the non-null values in the argument record to form a predicate from them. If all values in the record are null, the predicate will be the trueCondition().

Parameters:

record - The record from which to create a condition.

Returns:

The condition.

See Also:

https://en. wikipedia.org/wiki/Query_by_Example

noCondition
```
@Support
public static Condition noCondition()
```
Return a Condition that behaves like no condition being present.
This is useful as an "identity" condition for reduction operations, for both AND and OR reductions, e.g.
```
 Condition combined =
 Stream.of(cond1, cond2, cond3)
       .reduce(noCondition(), Condition::and);
 
```
When this condition is passed to SQL clauses, such as the WHERE clause, the entire clause is omitted:
```
 selectFrom(T).where(noCondition())
 
```
... will produce
```
 SELECT * FROM t
 
```

trueCondition
```
@Support
public static True trueCondition()
```
Return a Condition that will always evaluate to true.

falseCondition
```
@Support
public static False falseCondition()
```
Return a Condition that will always evaluate to false.

and

@Support
public static Condition and(Condition left,
                            Condition right)

Return a Condition that connects all argument conditions with Operator.AND.

and
```
@Support
public static Condition and(Condition... conditions)
```
Return a Condition that connects all argument conditions with Operator.AND.

and

@Support
public static Condition and(Collection<? extends Condition> conditions)

Return a Condition that connects all argument conditions with Operator.AND.

or

@Support
public static Condition or(Condition left,
                           Condition right)

Return a Condition that connects all argument conditions with Operator.OR.

or

@Support
public static Condition or(Condition... conditions)

Return a Condition that connects all argument conditions with Operator.OR.

or

@Support
public static Condition or(Collection<? extends Condition> conditions)

Return a Condition that connects all argument conditions with Operator.OR.

condition

@Support
public static Condition condition(Operator operator,
                                  Condition left,
                                  Condition right)

Return a Condition that connects all argument conditions with Operator.

condition

@Support
public static Condition condition(Operator operator,
                                  Condition... conditions)

Return a Condition that connects all argument conditions with Operator.

condition

@Support
public static Condition condition(Operator operator,
                                  Collection<? extends Condition> conditions)

Return a Condition that connects all argument conditions with Operator.

exists

@Support
public static Condition exists(Select<?> query)

Create an exists condition.

EXISTS ([query])

notExists

@Support
public static Condition notExists(Select<?> query)

Create a not exists condition.

NOT EXISTS ([query])

unique

@Support
public static Condition unique(Select<?> query)

Create a unique condition.

UNIQUE ([query])

notUnique

@Support
public static Condition notUnique(Select<?> query)

Create a not unique condition.

NOT UNIQUE ([query])

not

@Support
public static Condition not(Condition condition)

Invert a condition.

This is the same as calling Condition.not()

not
```
@Deprecated
@Support
public static Field<Boolean> not(Boolean value)
```
Deprecated.
- 3.8.0 - [#4763] - Use not(Condition) instead. Due to ambiguity between calling this method using Field.equals(Object) argument, vs. calling the other method via a Field.equal(Object) argument, this method will be removed in the future.
Invert a boolean value.
This is convenience for calling field(Condition), not(Condition), condition(Field), i.e.
```
 field(not(condition(field)));
 
```

not
```
@Support
public static Field<Boolean> not(Field<Boolean> field)
```
Invert a boolean value.
This is convenience for calling field(Condition), not(Condition), condition(Field), i.e.
```
 field(not(condition(field)));
 
```

field

@Support
public static Field<Boolean> field(Condition condition)

Transform a condition into a boolean field.

field

@Support
public static <T> Field<T> field(SelectField<T> field)

Wrap a SelectField in a general-purpose Field

rowField
```
@Support
public static <T1> Field<Record1<T1>> rowField(Row1<T1> row)
```
EXPERIMENTAL: Turn a row value expression of degree 1 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2> Field<Record2<T1,T2>> rowField(Row2<T1,T2> row)
```
EXPERIMENTAL: Turn a row value expression of degree 2 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3> Field<Record3<T1,T2,T3>> rowField(Row3<T1,T2,T3> row)
```
EXPERIMENTAL: Turn a row value expression of degree 3 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4> Field<Record4<T1,T2,T3,T4>> rowField(Row4<T1,T2,T3,T4> row)
```
EXPERIMENTAL: Turn a row value expression of degree 4 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4,T5> Field<Record5<T1,T2,T3,T4,T5>> rowField(Row5<T1,T2,T3,T4,T5> row)
```
EXPERIMENTAL: Turn a row value expression of degree 5 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4,T5,T6> Field<Record6<T1,T2,T3,T4,T5,T6>> rowField(Row6<T1,T2,T3,T4,T5,T6> row)
```
EXPERIMENTAL: Turn a row value expression of degree 6 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4,T5,T6,T7> Field<Record7<T1,T2,T3,T4,T5,T6,T7>> rowField(Row7<T1,T2,T3,T4,T5,T6,T7> row)
```
EXPERIMENTAL: Turn a row value expression of degree 7 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> Field<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> rowField(Row8<T1,T2,T3,T4,T5,T6,T7,T8> row)
```
EXPERIMENTAL: Turn a row value expression of degree 8 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Field<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> rowField(Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9> row)
```
EXPERIMENTAL: Turn a row value expression of degree 9 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Field<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> rowField(Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> row)
```
EXPERIMENTAL: Turn a row value expression of degree 10 into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Field<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> rowField(Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> row)

EXPERIMENTAL: Turn a row value expression of degree 11 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Field<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> rowField(Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> row)

EXPERIMENTAL: Turn a row value expression of degree 12 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Field<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> rowField(Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> row)

EXPERIMENTAL: Turn a row value expression of degree 13 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Field<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> rowField(Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> row)

EXPERIMENTAL: Turn a row value expression of degree 14 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Field<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> rowField(Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> row)

EXPERIMENTAL: Turn a row value expression of degree 15 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Field<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> rowField(Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> row)

EXPERIMENTAL: Turn a row value expression of degree 16 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Field<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> rowField(Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> row)

EXPERIMENTAL: Turn a row value expression of degree 17 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Field<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> rowField(Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> row)

EXPERIMENTAL: Turn a row value expression of degree 18 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Field<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> rowField(Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> row)

EXPERIMENTAL: Turn a row value expression of degree 19 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Field<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> rowField(Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> row)

EXPERIMENTAL: Turn a row value expression of degree 20 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Field<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> rowField(Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> row)

EXPERIMENTAL: Turn a row value expression of degree 21 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField

@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Field<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> rowField(Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> row)

EXPERIMENTAL: Turn a row value expression of degree 22 into a Field.

Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

rowField
```
@Support
public static Field<Record> rowField(RowN row)
```
EXPERIMENTAL: Turn a row value expression of arbitrary degree into a Field.
Note: Not all databases support row value expressions, but many row value expression operations can be emulated on all databases. See relevant row value expression method Javadocs for details.

field

@Support
public static <T> Field<T> field(Select<? extends Record1<T>> select)

Transform a subquery into a correlated subquery.

choose
```
@Support
public static Case choose()
```
Initialise a Case statement.
Choose is used as a method name to avoid name clashes with Java's reserved literal "case"

See Also:

Case

choose
```
@Support
public static <V> CaseValueStep<V> choose(V value)
```
Initialise a Case statement.
This API can be used to create expressions of the type
```
 CASE value WHEN 1 THEN 'one'
            WHEN 2 THEN 'two'
            ELSE        'three'
 END
 
```
Choose is used as a method name to avoid name clashes with Java's reserved literal "case".
See Also:

Case

choose
```
@Support
public static <V> CaseValueStep<V> choose(Field<V> value)
```
Initialise a Case statement.
This API can be used to create expressions of the type
```
 CASE value WHEN 1 THEN 'one'
            WHEN 2 THEN 'two'
            ELSE        'three'
 END
 
```
Choose is used as a method name to avoid name clashes with Java's reserved literal "case".
See Also:

Case

choose

@Support
public static <T> Field<T> choose(int index,
                                  T... values)

The T-SQL CHOOSE() function.

choose

@Support
@SafeVarargs
public static <T> Field<T> choose(int index,
                                  Field<T>... values)

The T-SQL CHOOSE() function.

choose

@Support
public static <T> Field<T> choose(Field<Integer> index,
                                  T... values)

The T-SQL CHOOSE() function.

choose

@Support
@SafeVarargs
public static <T> Field<T> choose(Field<Integer> index,
                                  Field<T>... values)

The T-SQL CHOOSE() function.

case_
```
@Support
public static Case case_()
```
Initialise a Case statement.

See Also:

Case

case_

@Support
public static <V> CaseValueStep<V> case_(V value)

Initialise a Case statement.

This API can be used to create expressions of the type

 CASE value WHEN 1 THEN 'one'
            WHEN 2 THEN 'two'
            ELSE        'three'
 END

See Also:: Case

case_

@Support
public static <V> CaseValueStep<V> case_(Field<V> value)

Initialise a Case statement.

This API can be used to create expressions of the type

 CASE value WHEN 1 THEN 'one'
            WHEN 2 THEN 'two'
            ELSE        'three'
 END

See Also:: Case

when

@Support
public static <T> CaseConditionStep<T> when(Condition condition,
                                            T result)

Initialise a Case statement.

This API can be used to create expressions of the type

 CASE WHEN x < 1  THEN 'one'
      WHEN x >= 2 THEN 'two'
      ELSE            'three'
 END

when

@Support
public static <T> CaseConditionStep<T> when(Condition condition,
                                            Field<T> result)

Initialise a Case statement.

This API can be used to create expressions of the type

 CASE WHEN x < 1  THEN 'one'
      WHEN x >= 2 THEN 'two'
      ELSE            'three'
 END

when

@Support
public static <T> CaseConditionStep<T> when(Condition condition,
                                            Select<? extends Record1<T>> result)

Initialise a Case statement.

This API can be used to create expressions of the type

 CASE WHEN x < 1  THEN 'one'
      WHEN x >= 2 THEN 'two'
      ELSE            'three'
 END

decode
```
@Support
public static Case decode()
```
Initialise a Case statement.
Decode is used as a method name to avoid name clashes with Java's reserved literal "case"

See Also:

Case

decode

@Support
public static <Z,T> Field<Z> decode(T value,
                                          T search,
                                          Z result)

Gets the Oracle-style DECODE(expression, search, result[, search , result]... [, default]) function.

See Also:: decode(Field, Field, Field, Field[])

decode

@Support
public static <Z,T> Field<Z> decode(T value,
                                          T search,
                                          Z result,
                                          Object... more)

Gets the Oracle-style DECODE(expression, search, result[, search , result]... [, default]) function.

See Also:: decode(Field, Field, Field, Field[])

decode

@Support
public static <Z,T> Field<Z> decode(Field<T> value,
                                          Field<T> search,
                                          Field<Z> result)

Gets the Oracle-style DECODE(expression, search, result[, search , result]... [, default]) function.

See Also:: decode(Field, Field, Field, Field[])

decode
```
@Support
public static <Z,T> Field<Z> decode(Field<T> value,
                                          Field<T> search,
                                          Field<Z> result,
                                          Field<?>... more)
```
Gets the Oracle-style DECODE(expression, search, result[, search , result]... [, default]) function.
Returns the dialect's equivalent to DECODE:
- Oracle DECODE
Other dialects:
```
 CASE WHEN [this IS NOT DISTINCT FROM search] THEN [result],
     [WHEN more...                            THEN more...]
     [ELSE more...]
 END
 
```
Note the use of the DISTINCT predicate to produce the same, conveniently NULL-agnostic behaviour as Oracle.
Parameters:

value - The value to decode

search - the mandatory first search parameter

result - the mandatory first result candidate parameter

more - the optional parameters. If more.length is even, then it is assumed that it contains more search/result pairs. If more.length is odd, then it is assumed that it contains more search/result pairs plus a default at the end.

coerce

@Support
public static <T> Field<T> coerce(Object value,
                                  Field<T> as)

Coerce this field to the type of another field.

See Also:: coerce(Field, Field)

coerce

@Support
public static <T> Field<T> coerce(Object value,
                                  Class<T> as)

Coerce this field to another type.

See Also:: coerce(Field, Class)

coerce

@Support
public static <T> Field<T> coerce(Object value,
                                  DataType<T> as)

Coerce a field to another type.

See Also:: coerce(Field, DataType)

coerce

@Support
public static <T> Field<T> coerce(Field<?> field,
                                  Field<T> as)

Coerce this field to the type of another field.

Unlike with casting, coercing doesn't affect the way the database sees a Field's type. This is how coercing affects your SQL:

Bind values

 // This binds an int value to a JDBC PreparedStatement
 DSL.val(1).coerce(String.class);

 // This binds an int value to a JDBC PreparedStatement
 // and casts it to VARCHAR in SQL
 DSL.val(1).cast(String.class);

Other Field types

 // This fetches a String value for the BOOK.ID field from JDBC
 BOOK.ID.coerce(String.class);

 // This fetches a String value for the BOOK.ID field from JDBC
 // after casting it to VARCHAR in the database
 BOOK.ID.cast(String.class);

Type Parameters:: T - The generic type of the coerced field
Parameters:: field - The field to be coerced; as - The field whose type is used for the coercion
Returns:: The coerced field
See Also:: Field.coerce(DataType), Field.cast(Field)

coerce

@Support
public static <T> Field<T> coerce(Field<?> field,
                                  Class<T> as)

Coerce this field to another type.

Unlike with casting, coercing doesn't affect the way the database sees a Field's type. This is how coercing affects your SQL:

Bind values

 // This binds an int value to a JDBC PreparedStatement
 DSL.val(1).coerce(String.class);

 // This binds an int value to a JDBC PreparedStatement
 // and casts it to VARCHAR in SQL
 DSL.val(1).cast(String.class);

Other Field types

 // This fetches a String value for the BOOK.ID field from JDBC
 BOOK.ID.coerce(String.class);

 // This fetches a String value for the BOOK.ID field from JDBC
 // after casting it to VARCHAR in the database
 BOOK.ID.cast(String.class);

Type Parameters:: T - The generic type of the coerced field
Parameters:: field - The field to be coerced; as - The type that is used for the coercion
Returns:: The coerced field
See Also:: Field.coerce(DataType), Field.cast(Class)

coerce

@Support
public static <T> Field<T> coerce(Field<?> field,
                                  DataType<T> as)

Coerce a field to another type.

Unlike with casting, coercing doesn't affect the way the database sees a Field's type. This is how coercing affects your SQL:

Bind values

 // This binds an int value to a JDBC PreparedStatement
 DSL.val(1).coerce(String.class);

 // This binds an int value to a JDBC PreparedStatement
 // and casts it to VARCHAR in SQL
 DSL.val(1).cast(String.class);

Other Field types

 // This fetches a String value for the BOOK.ID field from JDBC
 BOOK.ID.coerce(String.class);

 // This fetches a String value for the BOOK.ID field from JDBC
 // after casting it to VARCHAR in the database
 BOOK.ID.cast(String.class);

Type Parameters:: T - The generic type of the coerced field
Parameters:: field - The field to be coerced; as - The type that is used for the coercion
Returns:: The coerced field
See Also:: Field.coerce(DataType), Field.cast(DataType)

convert
```
@Support({ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Field<T> convert(DataType<T> type,
                                   Field<?> value,
                                   int style)
```
Convert a date time value to a string value using the SQL Server style CONVERT() function.

Type Parameters:

T - The generic type of the converted field

Parameters:

type - The data type to convert to

value - The expression to convert

style - The style according to the SQL Server docs

See Also:

https://docs.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-2017

convert
```
@Support({ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@Pro
public static <T> Field<T> convert(DataType<T> type,
                                   Object value,
                                   int style)
```
Convert a date time value to a string value using the SQL Server style CONVERT() function.

Type Parameters:

T - The generic type of the converted field

Parameters:

type - The data type to convert to

value - The expression to convert

style - The style according to the SQL Server docs

See Also:

https://docs.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-2017

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

Type Parameters:

T - The generic type of the cast field

Parameters:

value - The value to cast

as - The field whose type is used for the cast

Returns:

The cast field

cast
```
@Support
public static <T> Field<T> cast(Field<?> field,
                                Field<T> as)
```
Cast a field to the type of another field.

Type Parameters:

T - The generic type of the cast field

Parameters:

field - The field to cast

as - The field whose type is used for the cast

Returns:

The cast field

castNull
```
@Support
public static <T> Field<T> castNull(Field<T> as)
```
Cast null to the type of another field.

Type Parameters:

T - The generic type of the cast field

Parameters:

as - The field whose type is used for the cast

Returns:

The cast field

cast
```
@Support
public static <T> Field<T> cast(Object value,
                                Class<T> type)
```
Cast a value to another type.

Type Parameters:

T - The generic type of the cast field

Parameters:

value - The value to cast

type - The type that is used for the cast

Returns:

The cast field

cast
```
@Support
public static <T> Field<T> cast(Field<?> field,
                                Class<T> type)
```
Cast a field to another type.

Type Parameters:

T - The generic type of the cast field

Parameters:

field - The field to cast

type - The type that is used for the cast

Returns:

The cast field

castNull
```
@Support
public static <T> Field<T> castNull(DataType<T> type)
```
Cast null to a type.

Type Parameters:

T - The generic type of the cast field

Parameters:

type - The type that is used for the cast

Returns:

The cast field

cast
```
@Support
public static <T> Field<T> cast(Object value,
                                DataType<T> type)
```
Cast a value to another type.

Type Parameters:

T - The generic type of the cast field

Parameters:

value - The value to cast

type - The type that is used for the cast

Returns:

The cast field

cast
```
@Support
public static <T> Field<T> cast(Field<?> field,
                                DataType<T> type)
```
Cast a field to another type.

Type Parameters:

T - The generic type of the cast field

Parameters:

field - The value to cast

type - The type that is used for the cast

Returns:

The cast field

castNull
```
@Support
public static <T> Field<T> castNull(Class<T> type)
```
Cast null to a type.

Type Parameters:

T - The generic type of the cast field

Parameters:

type - The type that is used for the cast

Returns:

The cast field

coalesce

@Support
public static <T> Field<T> coalesce(T value,
                                    T... values)

The COALESCE(value1, value2, ... , value n) function.

See Also:: coalesce(Field, Field...)

coalesce

@Support
public static <T> Field<T> coalesce(Field<T> field,
                                    T value)

The COALESCE(field, value) function.

See Also:: coalesce(Field, Field...)

coalesce

@Support
public static <T> Field<T> coalesce(Field<T> field,
                                    Field<?>... fields)

The COALESCE(field1, field2, ... , field n) function.

isnull

@Support
public static <T> Field<T> isnull(T value,
                                  T defaultValue)

Gets the SQL Server-style ISNULL(value, defaultValue) function.

See Also:: nvl(Field, Field)

isnull

@Support
public static <T> Field<T> isnull(T value,
                                  Field<T> defaultValue)

Gets the SQL Server-style ISNULL(value, defaultValue) function.

See Also:: nvl(Field, Field)

isnull

@Support
public static <T> Field<T> isnull(Field<T> value,
                                  T defaultValue)

Gets the SQL Server-style ISNULL(value, defaultValue) function.

See Also:: nvl(Field, Field)

isnull

@Support
public static <T> Field<T> isnull(Field<T> value,
                                  Field<T> defaultValue)

Gets the SQL Server-style ISNULL(value, defaultValue) function.

See Also:: nvl(Field, Field)

nvl

@Support
public static <T> Field<T> nvl(T value,
                               T defaultValue)

Gets the Oracle-style NVL(value, defaultValue) function.

See Also:: nvl(Field, Field)

nvl

@Support
public static <T> Field<T> nvl(T value,
                               Field<T> defaultValue)

Gets the Oracle-style NVL(value, defaultValue) function.

See Also:: nvl(Field, Field)

nvl

@Support
public static <T> Field<T> nvl(Field<T> value,
                               T defaultValue)

Gets the Oracle-style NVL(value, defaultValue) function.

See Also:: nvl(Field, Field)

nvl
```
@Support
public static <T> Field<T> nvl(Field<T> value,
                               Field<T> defaultValue)
```
Gets the Oracle-style NVL(value, defaultValue) function.
Returns the dialect's equivalent to NVL:
- DB2 NVL
- Derby COALESCE
- H2 IFNULL
- HSQLDB NVL
- MySQL IFNULL
- Oracle NVL
- Postgres COALESCE
- SQLite IFNULL

ifnull

@Support
public static <T> Field<T> ifnull(T value,
                                  T defaultValue)

The IFNULL() function, a synonym of NVL().

See Also:: nvl(Field, Field)

ifnull

@Support
public static <T> Field<T> ifnull(T value,
                                  Field<T> defaultValue)

The IFNULL() function, a synonym of NVL().

See Also:: nvl(Field, Field)

ifnull

@Support
public static <T> Field<T> ifnull(Field<T> value,
                                  T defaultValue)

The IFNULL() function, a synonym of NVL().

See Also:: nvl(Field, Object)

ifnull

@Support
public static <T> Field<T> ifnull(Field<T> value,
                                  Field<T> defaultValue)

The IFNULL() function, a synonym of NVL().

See Also:: nvl(Field, Field)

nvl2

@Support
public static <Z> Field<Z> nvl2(Field<?> value,
                                Z valueIfNotNull,
                                Z valueIfNull)

Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.

See Also:: nvl2(Field, Field, Field)

nvl2

@Support
public static <Z> Field<Z> nvl2(Field<?> value,
                                Z valueIfNotNull,
                                Field<Z> valueIfNull)

Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.

See Also:: nvl2(Field, Field, Field)

nvl2

@Support
public static <Z> Field<Z> nvl2(Field<?> value,
                                Field<Z> valueIfNotNull,
                                Z valueIfNull)

Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.

See Also:: nvl2(Field, Field, Field)

nvl2

@Support
public static <Z> Field<Z> nvl2(Field<?> value,
                                Field<Z> valueIfNotNull,
                                Field<Z> valueIfNull)

Gets the Oracle-style NVL2(value, valueIfNotNull, valueIfNull) function.

Returns the dialect's equivalent to NVL2:

Oracle NVL2

Other dialects: CASE WHEN [value] IS NULL THEN [valueIfNull] ELSE [valueIfNotNull] END

nullif

@Support
public static <T> Field<T> nullif(T value,
                                  T other)

Gets the Oracle-style NULLIF(value, other) function.

See Also:: nullif(Field, Field)

nullif

@Support
public static <T> Field<T> nullif(T value,
                                  Field<T> other)

Gets the Oracle-style NULLIF(value, other) function.

See Also:: nullif(Field, Field)

nullif

@Support
public static <T> Field<T> nullif(Field<T> value,
                                  T other)

Gets the Oracle-style NULLIF(value, other) function.

See Also:: nullif(Field, Field)

nullif

@Support
public static <T> Field<T> nullif(Field<T> value,
                                  Field<T> other)

Gets the Oracle-style NULLIF(value, other) function.

Returns the dialect's equivalent to NULLIF:

Oracle NULLIF

iif

@Support
public static <T> Field<T> iif(Condition condition,
                               T ifTrue,
                               T ifFalse)

Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.

See Also:: iif(Condition, Field, Field)

iif

@Support
public static <T> Field<T> iif(Condition condition,
                               T ifTrue,
                               Field<T> ifFalse)

Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.

See Also:: iif(Condition, Field, Field)

iif

@Support
public static <T> Field<T> iif(Condition condition,
                               Field<T> ifTrue,
                               T ifFalse)

Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.

See Also:: iif(Condition, Field, Field)

iif

@Support
public static <T> Field<T> iif(Condition condition,
                               Field<T> ifTrue,
                               Field<T> ifFalse)

Gets the SQL Server style IIF(condition, ifTrue, ifFalse) function.

upper

@Support
public static Field<String> upper(String value)

Get the upper(field) function.

See Also:: upper(Field)

upper

@Support
public static Field<String> upper(Field<String> field)

Get the upper(field) function.

This renders the upper function in all dialects:

upper([field])

lower

@Support
public static Field<String> lower(String value)

Get the lower(field) function.

See Also:: lower(Field)

lower

@Support
public static Field<String> lower(Field<String> field)

Get the lower(field) function.

This renders the lower function in all dialects:

lower([field])

trim

@Support
public static Field<String> trim(String value)

Get the trim(field) function.

See Also:: trim(Field)

trim
```
@Support
public static Field<String> trim(Field<String> field)
```
Get the trim(field) function.
This renders the trim function where available:
```
trim([field])
```
... or emulates it elsewhere using rtrim and ltrim: ltrim(rtrim([field]))

trim

@Support({AURORA_POSTGRES,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLITE,SQLSERVER2017,TERADATA,VERTICA})
public static Field<String> trim(String value,
                                 String characters)

Get the trim(field, characters) or trim(both characters from field) function.

See Also:: trim(Field, Field)

trim

@Support({AURORA_POSTGRES,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLITE,SQLSERVER2017,TERADATA,VERTICA})
public static Field<String> trim(Field<String> field,
                                 Field<String> characters)

Get the trim(field, characters) or trim(both characters from field) function.

This renders the trim function where available:

trim([field])

... or emulates it elsewhere using rtrim and ltrim: ltrim(rtrim([field]))

rtrim

@Support
public static Field<String> rtrim(String value)

Get the rtrim(field) function.

See Also:: rtrim(Field)

rtrim

@Support
public static Field<String> rtrim(Field<String> field)

Get the rtrim(field) function.

This renders the rtrim function in all dialects:

rtrim([field])

rtrim

@Support({AURORA_POSTGRES,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLITE,TERADATA,VERTICA})
public static Field<String> rtrim(String value,
                                  String characters)

Get the rtrim(field, characters) or trim(trailing characters from field) function.

See Also:: rtrim(Field, Field)

rtrim

@Support({AURORA_POSTGRES,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLITE,TERADATA,VERTICA})
public static Field<String> rtrim(Field<String> field,
                                  Field<String> characters)

Get the rtrim(field, characters) or trim(trailing characters from field) function.

This renders the rtrim function in all dialects:

rtrim([field])

ltrim

@Support
public static Field<String> ltrim(String value)

Get the ltrim(field) function.

See Also:: ltrim(Field)

ltrim

@Support
public static Field<String> ltrim(Field<String> field)

Get the ltrim(field) function.

This renders the ltrim function in all dialects:

ltrim([field])

ltrim

@Support({AURORA_POSTGRES,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLITE,TERADATA,VERTICA})
public static Field<String> ltrim(String value,
                                  String characters)

Get the ltrim(field, characters) or trim(leading characters from field) function.

See Also:: ltrim(Field, Field)

ltrim

@Support({AURORA_POSTGRES,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLITE,TERADATA,VERTICA})
public static Field<String> ltrim(Field<String> field,
                                  Field<String> characters)

Get the ltrim(field, characters) or trim(leading characters from field) function.

This renders the ltrim function in all dialects:

ltrim([field])

rpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> rpad(Field<String> field,
                                 int length)

Get the rpad(field, length) function.

See Also:: rpad(Field, Field)

rpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> rpad(Field<String> field,
                                 Field<? extends Number> length)

Get the rpad(field, length) function.

This renders the rpad function where available:

rpad([field], [length])

... or emulates it elsewhere using concat, repeat, and length, which may be emulated as well, depending on the RDBMS: concat([field], repeat(' ', [length] - length([field])))

rpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> rpad(Field<String> field,
                                 int length,
                                 char character)

Get the rpad(field, length, character) function.

See Also:: rpad(Field, Field, Field)

rpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> rpad(Field<String> field,
                                 int length,
                                 String character)

Get the rpad(field, length, character) function.

See Also:: rpad(Field, Field, Field)

rpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> rpad(Field<String> field,
                                 Field<? extends Number> length,
                                 Field<String> character)

Get the rpad(field, length, character) function.

This renders the rpad function where available:

rpad([field], [length])

... or emulates it elsewhere using concat, repeat, and length, which may be emulated as well, depending on the RDBMS: concat([field], repeat([character], [length] - length([field])))

In SQLDialect.SQLITE, this is emulated as such:

[field] || replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '\''', ''), '0', [character])

lpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> lpad(Field<String> field,
                                 int length)

Get the lpad(field, length) function.

See Also:: lpad(Field, Field)

lpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> lpad(Field<String> field,
                                 Field<? extends Number> length)

Get the lpad(field, length) function.

This renders the lpad function where available:

lpad([field], [length])

... or emulates it elsewhere using concat, repeat, and length, which may be emulated as well, depending on the RDBMS: concat(repeat(' ', [length] - length([field])), [field])

lpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> lpad(Field<String> field,
                                 int length,
                                 char character)

Get the lpad(field, length, character) function.

See Also:: lpad(Field, Field, Field)

lpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> lpad(Field<String> field,
                                 int length,
                                 String character)

Get the lpad(field, length, character) function.

See Also:: lpad(Field, Field, Field)

lpad

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> lpad(Field<String> field,
                                 Field<? extends Number> length,
                                 Field<String> character)

Get the lpad(field, length, character) function.

This renders the lpad function where available:

lpad([field], [length])

... or emulates it elsewhere using concat, repeat, and length, which may be emulated as well, depending on the RDBMS: concat(repeat([character], [length] - length([field])), [field])

In SQLDialect.SQLITE, this is emulated as such:

replace(replace(substr(quote(zeroblob(([length] + 1) / 2)), 3, ([length] - length([field]))), '\''', ''), '0', [character]) || [field]

translate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER2017,TERADATA})
public static Field<String> translate(Field<String> text,
                                      String from,
                                      String to)

Get the translate(field, from, to) function.

See Also:: translate(Field, Field, Field)

translate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER2017,TERADATA})
public static Field<String> translate(Field<String> text,
                                      Field<String> from,
                                      Field<String> to)

Get the translate(field, from, to) function.

repeat

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> repeat(String field,
                                   int count)

Get the repeat(field, count) function.

See Also:: repeat(Field, Field)

repeat

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> repeat(String field,
                                   Field<? extends Number> count)

Get the repeat(field, count) function.

See Also:: repeat(Field, Field)

repeat

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> repeat(Field<String> field,
                                   int count)

Get the repeat(count) function.

See Also:: repeat(Field, Field)

repeat

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> repeat(Field<String> field,
                                   Field<? extends Number> count)

Get the repeat(field, count) function.

This renders the repeat or replicate function where available:

repeat([field], [count]) or
 replicate([field], [count])

... or emulates it elsewhere using rpad and length, which may be emulated as well, depending on the RDBMS: rpad([field], length([field]) * [count], [field])

In SQLDialect.SQLITE, this is emulated as such:

replace(substr(quote(zeroblob(([count] + 1) / 2)), 3, [count]), '0', [field])

space

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> space(int value)

Get the SQL Server specific SPACE() function.

This function can be emulated using repeat(String, int) in dialects that do not ship with a native SPACE() function.

See Also:: http://technet.microsoft.com/en-us/library/ms187950.aspx

space

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> space(Field<Integer> value)

Get the SQL Server specific SPACE() function.

This function can be emulated using repeat(String, int) in dialects that do not ship with a native SPACE() function.

See Also:: http://technet.microsoft.com/en-us/library/ms187950.aspx

reverse

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
public static Field<String> reverse(String value)

Get the reverse(field) function.

reverse

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,HSQLDB,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
public static Field<String> reverse(Field<String> field)

Get the reverse(field) function.

escape

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static String escape(String value,
                            char escape)

Convenience method for replace(Field, String, String) to escape data for use with Field.like(Field, char).

Essentially, this escapes % and _ characters

See Also:: replace(Field, String, String), Field.like(Field, char)

escape

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
public static Field<String> escape(Field<String> field,
                                   char escape)

Convenience method for replace(Field, String, String) to escape data for use with Field.like(Field, char).

Essentially, this escapes % and _ characters

See Also:: replace(Field, String, String), Field.like(Field, char)

replace

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> replace(Field<String> field,
                                    String search)

Get the replace(field, search) function.

See Also:: replace(Field, Field)

replace

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> replace(Field<String> field,
                                    Field<String> search)

Get the replace(field, search) function.

This renders the replace or str_replace function where available:

replace([field], [search]) or
 str_replace([field], [search])

... or emulates it elsewhere using the three-argument replace function: replace([field], [search], '')

replace

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> replace(Field<String> field,
                                    String search,
                                    String replace)

Get the replace(field, search, replace) function.

See Also:: replace(Field, Field, Field)

replace

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<String> replace(Field<String> field,
                                    Field<String> search,
                                    Field<String> replace)

Get the replace(field, search, replace) function.

This renders the replace or str_replace function:

replace([field], [search]) or
 str_replace([field], [search])

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(String in,
                                      String search)

Get the position(in, search) function.

See Also:: position(Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(String in,
                                      Field<String> search)

Get the position(in, search) function.

See Also:: position(Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(Field<String> in,
                                      String search)

Get the position(in, search) function.

See Also:: position(Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(Field<String> in,
                                      Field<String> search)

Get the position(in, search) function.

This renders the position or any equivalent function:

position([search] in [in]) or
 locate([in], [search]) or
 locate([search], [in]) or
 instr([in], [search]) or
 charindex([search], [in])

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(String in,
                                      String search,
                                      int startIndex)

Get the position(in, search, startindex) function.

See Also:: position(Field, Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(String in,
                                      Field<String> search,
                                      int startIndex)

Get the position(in, search, startindex) function.

See Also:: position(Field, Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(Field<String> in,
                                      String search,
                                      int startIndex)

Get the position(in, search, startindex) function.

See Also:: position(Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(Field<String> in,
                                      Field<String> search,
                                      int startIndex)

Get the position(in, search, startindex) function.

This renders the position or any equivalent function:

position([search] in [in]) or
 locate([in], [search]) or
 locate([search], [in]) or
 instr([in], [search]) or
 charindex([search], [in])

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(String in,
                                      String search,
                                      Field<? extends Number> startIndex)

Get the position(in, search, startindex) function.

See Also:: position(Field, Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(String in,
                                      Field<String> search,
                                      Field<? extends Number> startIndex)

Get the position(in, search, startindex) function.

See Also:: position(Field, Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(Field<String> in,
                                      String search,
                                      Field<? extends Number> startIndex)

Get the position(in, search, startindex) function.

See Also:: position(Field, Field)

position

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> position(Field<String> in,
                                      Field<String> search,
                                      Field<? extends Number> startIndex)

Get the position(in, search, startindex) function.

This renders the position or any equivalent function:

position([search] in [in]) or
 locate([in], [search]) or
 locate([search], [in]) or
 instr([in], [search]) or
 charindex([search], [in])

ascii

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> ascii(String field)

Get the ascii(field) function.

See Also:: ascii(Field)

ascii

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Integer> ascii(Field<String> field)

Get the ascii(field) function.

This renders the ascii function:

ascii([field])

concat

@Support
public static Field<String> concat(Field<String> field,
                                   String value)

Get the concat(field, value) function.

See Also:: concat(Field...)

concat

@Support
public static Field<String> concat(String value,
                                   Field<String> field)

Get the concat(value, field) function.

See Also:: concat(Field...)

concat
```
@Support
public static Field<String> concat(String... values)
```
Get the concat(value[, value, ...]) function.

See Also:

concat(Field...)

concat
```
@Support
public static Field<String> concat(Field<?>... fields)
```
Get the concat(field[, field, ...]) function.
This creates fields[0] || fields[1] || ... as an expression, or concat(fields[0], fields[1], ...), depending on the dialect.
If any of the given fields is not a String field, they are cast to Field<String> first using cast(Object, Class)

substring

@Support
public static Field<String> substring(Field<String> field,
                                      int startingPosition)

Get the substring(field, startingPosition) function.

See Also:: substring(Field, Field)

substring

@Support
public static Field<String> substring(Field<String> field,
                                      Field<? extends Number> startingPosition)

Get the substring(field, startingPosition) function.

This renders the substr or substring function:

substr([field], [startingPosition]) or
 substring([field], [startingPosition])

substring

@Support
public static Field<String> substring(Field<String> field,
                                      int startingPosition,
                                      int length)

Get the substring(field, startingPosition, length) function.

See Also:: substring(Field, Field, Field)

substring

@Support
public static Field<String> substring(Field<String> field,
                                      Field<? extends Number> startingPosition,
                                      Field<? extends Number> length)

Get the substring(field, startingPosition, length) function.

This renders the substr or substring function:

substr([field], [startingPosition], [length]) or
 substring([field], [startingPosition], [length])

mid

@Support
public static Field<String> mid(Field<String> field,
                                int startingPosition,
                                int length)

Get the mid(field, startingPosition, length) function.

See Also:: substring(Field, Field, Field)

mid

@Support
public static Field<String> mid(Field<String> field,
                                Field<? extends Number> startingPosition,
                                Field<? extends Number> length)

Get the mid(field, startingPosition, length) function.

This renders the substr or substring function:

substr([field], [startingPosition], [length]) or
 substring([field], [startingPosition], [length])

left

@Support
public static Field<String> left(String field,
                                 int length)

Get the left outermost characters from a string.

Example:

 'abc' = LEFT('abcde', 3)

left

@Support
public static Field<String> left(String field,
                                 Field<? extends Number> length)

Get the left outermost characters from a string.

Example:

 'abc' = LEFT('abcde', 3)

left

@Support
public static Field<String> left(Field<String> field,
                                 int length)

Get the left outermost characters from a string.

Example:

 'abc' = LEFT('abcde', 3)

left

@Support
public static Field<String> left(Field<String> field,
                                 Field<? extends Number> length)

Get the left outermost characters from a string.

Example:

 'abc' = LEFT('abcde', 3)

right

@Support
public static Field<String> right(String field,
                                  int length)

Get the right outermost characters from a string.

Example:

 'cde' = RIGHT('abcde', 3)

right

@Support
public static Field<String> right(String field,
                                  Field<? extends Number> length)

Get the right outermost characters from a string.

Example:

 'cde' = RIGHT('abcde', 3)

right

@Support
public static Field<String> right(Field<String> field,
                                  int length)

Get the right outermost characters from a string.

Example:

 'cde' = RIGHT('abcde', 3)

right

@Support
public static Field<String> right(Field<String> field,
                                  Field<? extends Number> length)

Get the right outermost characters from a string.

Example:

 'cde' = RIGHT('abcde', 3)

length
```
@Support
public static Field<Integer> length(String value)
```
Get the length of a VARCHAR type. This is a synonym for charLength(String).

See Also:

charLength(String)

length
```
@Support
public static Field<Integer> length(Field<String> field)
```
Get the length of a VARCHAR type. This is a synonym for charLength(Field).

See Also:

charLength(Field)

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

charLength

@Support
public static Field<Integer> charLength(Field<String> field)

Get the char_length(field) function.

This translates into any dialect

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

bitLength

@Support
public static Field<Integer> bitLength(Field<String> field)

Get the bit_length(field) function.

This translates into any dialect

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

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

md5

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,ORACLE,SQLDATAWAREHOUSE,SQLSERVER})
public static Field<String> md5(String string)

Get the MySQL-specific MD5() function.

These are the implementations for various databases:

Database	Implementation
MySQL	`MD5( ... )`
Oracle 11g	`LOWER(RAWTOHEX(SYS.DBMS_CRYPTO.HASH(UTL_RAW.CAST_TO_RAW( ... ), SYS.DBMS_CRYPTO.HASH_MD5)))`
Oracle 12c	`LOWER(STANDARD_HASH( ... , 'MD5'))`

md5

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,ORACLE,SQLDATAWAREHOUSE,SQLSERVER})
public static Field<String> md5(Field<String> string)

Get the MySQL-specific MD5() function.

These are the implementations for various databases:

Database	Implementation
MySQL	`MD5( ... )`
Oracle 11g	`LOWER(RAWTOHEX(SYS.DBMS_CRYPTO.HASH(UTL_RAW.CAST_TO_RAW( ... ), SYS.DBMS_CRYPTO.HASH_MD5)))`
Oracle 12c	`LOWER(STANDARD_HASH( ... , 'MD5'))`

currentDate
```
@Support
public static Field<Date> currentDate()
```
Get the current_date() function returning a SQL standard SQLDataType.DATE type.
Note, while there is a CURRENT_DATE function in SQLDialect.ORACLE, that function returns a seconds-precision SQLDataType.TIMESTAMP, which is undesired from a vendor agnosticity perspective. This function thus produces an expression that conforms to the SQL standard idea of a SQLDataType.DATE type.
This translates into any dialect

currentTime
```
@Support
public static Field<Time> currentTime()
```
Get the current_time() function returning a SQL standard SQLDataType.TIME type.
This translates into any dialect

currentTimestamp
```
@Support
public static Field<Timestamp> currentTimestamp()
```
Get the current_timestamp() function returning a SQL standard SQLDataType.TIMESTAMP type.
This translates into any dialect

currentTimestamp

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
public static Field<Timestamp> currentTimestamp(Field<Integer> precision)

Get the current_timestamp() function returning a SQL standard SQLDataType.TIMESTAMP type with the specified fractional seconds precision.

now

@Support
public static Field<Timestamp> now()

Synonym for currentTimestamp().

now

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
public static Field<Timestamp> now(Field<Integer> precision)

Synonym for currentTimestamp(Field).

currentLocalDate
```
@Support
public static Field<LocalDate> currentLocalDate()
```
Get the current_date() function returning a SQL standard SQLDataType.DATE type.
Note, while there is a CURRENT_DATE function in SQLDialect.ORACLE, that function returns a seconds-precision SQLDataType.TIMESTAMP, which is undesired from a vendor agnosticity perspective. This function thus produces an expression that conforms to the SQL standard idea of a SQLDataType.DATE type.
This translates into any dialect

currentLocalTime
```
@Support
public static Field<LocalTime> currentLocalTime()
```
Get the current_time() function returning a SQL standard SQLDataType.TIME type.
This translates into any dialect

currentLocalDateTime
```
@Support
public static Field<LocalDateTime> currentLocalDateTime()
```
Get the current_timestamp() function returning a SQL standard SQLDataType.TIMESTAMP type.
This translates into any dialect

currentOffsetTime
```
@Support
public static Field<OffsetTime> currentOffsetTime()
```
Get the current_time() function.
This translates into any dialect

currentOffsetDateTime
```
@Support
public static Field<OffsetDateTime> currentOffsetDateTime()
```
Get the current_timestamp() function.
This translates into any dialect

currentInstant
```
@Support
public static Field<Instant> currentInstant()
```
Get the current_timestamp() function.
This translates into any dialect

dateDiff

@Support
public static Field<Integer> dateDiff(Date date1,
                                      Date date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

dateDiff

@Support
public static Field<Integer> dateDiff(Field<Date> date1,
                                      Date date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

dateDiff

@Support
public static Field<Integer> dateDiff(Date date1,
                                      Field<Date> date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

dateDiff

@Support
public static Field<Integer> dateDiff(Field<Date> date1,
                                      Field<Date> date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

dateAdd

@Support
public static Field<Date> dateAdd(Date date,
                                  Number interval)

Add an interval to a date.

This translates into any dialect

See Also:: Field.add(Number)

dateAdd

@Support
public static Field<Date> dateAdd(Field<Date> date,
                                  Field<? extends Number> interval)

Add an interval to a date.

This translates into any dialect

See Also:: Field.add(Field)

dateAdd

@Support
public static Field<Date> dateAdd(Date date,
                                  Number interval,
                                  DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

dateAdd

@Support
public static Field<Date> dateAdd(Date date,
                                  Field<? extends Number> interval,
                                  DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

dateAdd

@Support
public static Field<Date> dateAdd(Field<Date> date,
                                  Number interval,
                                  DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

dateAdd

@Support
public static Field<Date> dateAdd(Field<Date> date,
                                  Field<? extends Number> interval,
                                  DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

dateSub

@Support
public static Field<Date> dateSub(Date date,
                                  Number interval)

Subtract an interval from a date.

This translates into any dialect

See Also:: Field.add(Number)

dateSub

@Support
public static Field<Date> dateSub(Field<Date> date,
                                  Field<? extends Number> interval)

Subtract an interval from a date.

This translates into any dialect

See Also:: Field.add(Field)

dateSub

@Support
public static Field<Date> dateSub(Date date,
                                  Number interval,
                                  DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

dateSub

@Support
public static Field<Date> dateSub(Date date,
                                  Field<? extends Number> interval,
                                  DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

dateSub

@Support
public static Field<Date> dateSub(Field<Date> date,
                                  Number interval,
                                  DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

dateSub

@Support
public static Field<Date> dateSub(Field<Date> date,
                                  Field<? extends Number> interval,
                                  DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

timestampAdd

@Support
public static Field<Timestamp> timestampAdd(Timestamp timestamp,
                                            Number interval)

Add an interval to a timestamp.

This translates into any dialect

See Also:: Field.add(Number)

timestampAdd

@Support
public static Field<Timestamp> timestampAdd(Field<Timestamp> timestamp,
                                            Field<? extends Number> interval)

Add an interval to a timestamp.

This translates into any dialect

See Also:: Field.add(Field)

timestampAdd

@Support
public static Field<Timestamp> timestampAdd(Timestamp date,
                                            Number interval,
                                            DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

timestampAdd

@Support
public static Field<Timestamp> timestampAdd(Timestamp date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

timestampAdd

@Support
public static Field<Timestamp> timestampAdd(Field<Timestamp> date,
                                            Number interval,
                                            DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

timestampAdd

@Support
public static Field<Timestamp> timestampAdd(Field<Timestamp> date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

timestampSub

@Support
public static Field<Timestamp> timestampSub(Timestamp timestamp,
                                            Number interval)

Subtract an interval from a timestamp.

This translates into any dialect

See Also:: Field.sub(Number)

timestampSub

@Support
public static Field<Timestamp> timestampSub(Field<Timestamp> timestamp,
                                            Field<? extends Number> interval)

Subtract an interval from a timestamp.

This translates into any dialect

See Also:: Field.sub(Field)

timestampSub

@Support
public static Field<Timestamp> timestampSub(Timestamp date,
                                            Number interval,
                                            DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

timestampSub

@Support
public static Field<Timestamp> timestampSub(Timestamp date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

timestampSub

@Support
public static Field<Timestamp> timestampSub(Field<Timestamp> date,
                                            Number interval,
                                            DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

timestampSub

@Support
public static Field<Timestamp> timestampSub(Field<Timestamp> date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

timestampDiff

@Support
public static Field<DayToSecond> timestampDiff(Timestamp timestamp1,
                                               Timestamp timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

timestampDiff

@Support
public static Field<DayToSecond> timestampDiff(Field<Timestamp> timestamp1,
                                               Timestamp timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

timestampDiff

@Support
public static Field<DayToSecond> timestampDiff(Timestamp timestamp1,
                                               Field<Timestamp> timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

timestampDiff

@Support
public static Field<DayToSecond> timestampDiff(Field<Timestamp> timestamp1,
                                               Field<Timestamp> timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

localDateDiff

@Support
public static Field<Integer> localDateDiff(LocalDate date1,
                                           LocalDate date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

localDateDiff

@Support
public static Field<Integer> localDateDiff(Field<LocalDate> date1,
                                           LocalDate date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

localDateDiff

@Support
public static Field<Integer> localDateDiff(LocalDate date1,
                                           Field<LocalDate> date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

localDateDiff

@Support
public static Field<Integer> localDateDiff(Field<LocalDate> date1,
                                           Field<LocalDate> date2)

Get the date difference in number of days.

This translates into any dialect

See Also:: Field.sub(Field)

localDateAdd

@Support
public static Field<LocalDate> localDateAdd(LocalDate date,
                                            Number interval)

Add an interval to a date.

This translates into any dialect

See Also:: Field.add(Number)

localDateAdd

@Support
public static Field<LocalDate> localDateAdd(Field<LocalDate> date,
                                            Field<? extends Number> interval)

Add an interval to a date.

This translates into any dialect

See Also:: Field.add(Field)

localDateAdd

@Support
public static Field<LocalDate> localDateAdd(LocalDate date,
                                            Number interval,
                                            DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

localDateAdd

@Support
public static Field<LocalDate> localDateAdd(LocalDate date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

localDateAdd

@Support
public static Field<LocalDate> localDateAdd(Field<LocalDate> date,
                                            Number interval,
                                            DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

localDateAdd

@Support
public static Field<LocalDate> localDateAdd(Field<LocalDate> date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Add an interval to a date, given a date part.

This translates into any dialect

localDateSub

@Support
public static Field<LocalDate> localDateSub(LocalDate date,
                                            Number interval)

Subtract an interval from a date.

This translates into any dialect

See Also:: Field.add(Number)

localDateSub

@Support
public static Field<LocalDate> localDateSub(Field<LocalDate> date,
                                            Field<? extends Number> interval)

Subtract an interval from a date.

This translates into any dialect

See Also:: Field.add(Field)

localDateSub

@Support
public static Field<LocalDate> localDateSub(LocalDate date,
                                            Number interval,
                                            DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

localDateSub

@Support
public static Field<LocalDate> localDateSub(LocalDate date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

localDateSub

@Support
public static Field<LocalDate> localDateSub(Field<LocalDate> date,
                                            Number interval,
                                            DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

localDateSub

@Support
public static Field<LocalDate> localDateSub(Field<LocalDate> date,
                                            Field<? extends Number> interval,
                                            DatePart datePart)

Subtract an interval from a date, given a date part.

This translates into any dialect

localDateTimeAdd

@Support
public static Field<LocalDateTime> localDateTimeAdd(LocalDateTime timestamp,
                                                    Number interval)

Add an interval to a timestamp.

This translates into any dialect

See Also:: Field.add(Number)

localDateTimeAdd

@Support
public static Field<LocalDateTime> localDateTimeAdd(Field<LocalDateTime> timestamp,
                                                    Field<? extends Number> interval)

Add an interval to a timestamp.

This translates into any dialect

See Also:: Field.add(Field)

localDateTimeAdd

@Support
public static Field<LocalDateTime> localDateTimeAdd(LocalDateTime date,
                                                    Number interval,
                                                    DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

localDateTimeAdd

@Support
public static Field<LocalDateTime> localDateTimeAdd(LocalDateTime date,
                                                    Field<? extends Number> interval,
                                                    DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

localDateTimeAdd

@Support
public static Field<LocalDateTime> localDateTimeAdd(Field<LocalDateTime> date,
                                                    Number interval,
                                                    DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

localDateTimeAdd

@Support
public static Field<LocalDateTime> localDateTimeAdd(Field<LocalDateTime> date,
                                                    Field<? extends Number> interval,
                                                    DatePart datePart)

Add an interval to a timestamp, given a date part.

This translates into any dialect

localDateTimeSub

@Support
public static Field<LocalDateTime> localDateTimeSub(LocalDateTime timestamp,
                                                    Number interval)

Subtract an interval from a timestamp.

This translates into any dialect

See Also:: Field.sub(Number)

localDateTimeSub

@Support
public static Field<LocalDateTime> localDateTimeSub(Field<LocalDateTime> timestamp,
                                                    Field<? extends Number> interval)

Subtract an interval from a timestamp.

This translates into any dialect

See Also:: Field.sub(Field)

localDateTimeSub

@Support
public static Field<LocalDateTime> localDateTimeSub(LocalDateTime date,
                                                    Number interval,
                                                    DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

localDateTimeSub

@Support
public static Field<LocalDateTime> localDateTimeSub(LocalDateTime date,
                                                    Field<? extends Number> interval,
                                                    DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

localDateTimeSub

@Support
public static Field<LocalDateTime> localDateTimeSub(Field<LocalDateTime> date,
                                                    Number interval,
                                                    DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

localDateTimeSub

@Support
public static Field<LocalDateTime> localDateTimeSub(Field<LocalDateTime> date,
                                                    Field<? extends Number> interval,
                                                    DatePart datePart)

Subtract an interval from a timestamp, given a date part.

This translates into any dialect

localDateTimeDiff

@Support
public static Field<DayToSecond> localDateTimeDiff(LocalDateTime timestamp1,
                                                   LocalDateTime timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

localDateTimeDiff

@Support
public static Field<DayToSecond> localDateTimeDiff(Field<LocalDateTime> timestamp1,
                                                   LocalDateTime timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

localDateTimeDiff

@Support
public static Field<DayToSecond> localDateTimeDiff(LocalDateTime timestamp1,
                                                   Field<LocalDateTime> timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

localDateTimeDiff

@Support
public static Field<DayToSecond> localDateTimeDiff(Field<LocalDateTime> timestamp1,
                                                   Field<LocalDateTime> timestamp2)

Get the timestamp difference as a INTERVAL DAY TO SECOND type.

This translates into any dialect

See Also:: Field.sub(Field)

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<Date> trunc(Date date)

Truncate a date to the beginning of the day.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<Date> trunc(Date date,
                                DatePart part)

Truncate a date to a given datepart.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDate> trunc(LocalDate date)

Truncate a date to the beginning of the day.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDate> trunc(LocalDate date,
                                     DatePart part)

Truncate a date to a given datepart.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<Timestamp> trunc(Timestamp timestamp)

Truncate a timestamp to the beginning of the day.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<Timestamp> trunc(Timestamp timestamp,
                                     DatePart part)

Truncate a timestamp to a given datepart.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDateTime> trunc(LocalDateTime timestamp)

Truncate a timestamp to the beginning of the day.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDateTime> trunc(LocalDateTime timestamp,
                                         DatePart part)

Truncate a timestamp to a given datepart.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static <T> Field<T> trunc(Field<T> date)

Truncate a date or a timestamp to the beginning of the day.

trunc

@Support({AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,VERTICA})
public static <T> Field<T> trunc(Field<T> date,
                                 DatePart part)

Truncate a date or a timestamp to a given datepart.

extract

@Support
public static Field<Integer> extract(Date value,
                                     DatePart datePart)

Get the extract(field, datePart) function.

This translates into any dialect

extract

@Support
public static Field<Integer> extract(Temporal value,
                                     DatePart datePart)

Get the extract(field, datePart) function.

This translates into any dialect

extract

@Support
public static Field<Integer> extract(Field<?> field,
                                     DatePart datePart)

Get the extract(field, datePart) function.

This translates into any dialect

epoch

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> epoch(Date value)

Get the epoch of a date.

This is the same as calling extract(Field, DatePart) with DatePart.EPOCH

epoch

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> epoch(Temporal value)

Get the epoch of a date.

This is the same as calling extract(Field, DatePart) with DatePart.EPOCH

epoch

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> epoch(Field<?> field)

Get the epoch of a date.

This is the same as calling extract(Field, DatePart) with DatePart.EPOCH

millennium
```
@Support
public static Field<Integer> millennium(Date value)
```
Get the millennium of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MILLENNIUM

millennium
```
@Support
public static Field<Integer> millennium(Temporal value)
```
Get the millennium of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MILLENNIUM

millennium
```
@Support
public static Field<Integer> millennium(Field<?> field)
```
Get the millennium of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MILLENNIUM

century
```
@Support
public static Field<Integer> century(Date value)
```
Get the century of a date.
This is the same as calling extract(Field, DatePart) with DatePart.CENTURY

century
```
@Support
public static Field<Integer> century(Temporal value)
```
Get the century of a date.
This is the same as calling extract(Field, DatePart) with DatePart.CENTURY

century
```
@Support
public static Field<Integer> century(Field<?> field)
```
Get the century of a date.
This is the same as calling extract(Field, DatePart) with DatePart.CENTURY

decade
```
@Support
public static Field<Integer> decade(Date value)
```
Get the decade of a date.
This is the same as calling extract(Field, DatePart) with DatePart.DECADE

decade
```
@Support
public static Field<Integer> decade(Temporal value)
```
Get the decade of a date.
This is the same as calling extract(Field, DatePart) with DatePart.DECADE

decade
```
@Support
public static Field<Integer> decade(Field<?> field)
```
Get the decade of a date.
This is the same as calling extract(Field, DatePart) with DatePart.DECADE

quarter
```
@Support
public static Field<Integer> quarter(Date value)
```
Get the quarter of a date.
This is the same as calling extract(Field, DatePart) with DatePart.QUARTER

quarter
```
@Support
public static Field<Integer> quarter(Temporal value)
```
Get the quarter of a date.
This is the same as calling extract(Field, DatePart) with DatePart.QUARTER

quarter
```
@Support
public static Field<Integer> quarter(Field<?> field)
```
Get the quarter of a date.
This is the same as calling extract(Field, DatePart) with DatePart.QUARTER

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

year
```
@Support
public static Field<Integer> year(Temporal value)
```
Get the year part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.YEAR

year
```
@Support
public static Field<Integer> year(Field<?> field)
```
Get the year part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.YEAR

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

month
```
@Support
public static Field<Integer> month(Temporal value)
```
Get the month part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.MONTH

month
```
@Support
public static Field<Integer> month(Field<?> field)
```
Get the month part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MONTH

week
```
@Support({AURORA_POSTGRES,H2,MEMSQL,POSTGRES})
public static Field<Integer> week(Date value)
```
Get the week part of a date.
This is the same as calling extract(java.util.Date, DatePart) with DatePart.WEEK

week

@Support({AURORA_POSTGRES,H2,MEMSQL,POSTGRES})
public static Field<Integer> week(Temporal value)

Get the week part of a date.

This is the same as calling extract(Temporal, DatePart) with DatePart.WEEK

week

@Support({AURORA_POSTGRES,H2,HSQLDB,MEMSQL,POSTGRES})
public static Field<Integer> week(Field<?> field)

Get the week part of a date.

This is the same as calling extract(Field, DatePart) with DatePart.WEEK

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

day
```
@Support
public static Field<Integer> day(Temporal value)
```
Get the day part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.DAY

day
```
@Support
public static Field<Integer> day(Field<?> field)
```
Get the day part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.DAY

dayOfWeek

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> dayOfWeek(Date value)

Get the day of week part of a date.

This is the same as calling extract(java.util.Date, DatePart) with DatePart.DAY_OF_WEEK

dayOfWeek

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> dayOfWeek(Temporal value)

Get the day of week part of a date.

This is the same as calling extract(Temporal, DatePart) with DatePart.DAY_OF_WEEK

dayOfWeek

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> dayOfWeek(Field<?> field)

Get the day of week part of a date.

This is the same as calling extract(Field, DatePart) with DatePart.DAY_OF_WEEK

isoDayOfWeek

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> isoDayOfWeek(Date value)

Get the ISO day of week part of a date.

This is the same as calling extract(java.util.Date, DatePart) with DatePart.ISO_DAY_OF_WEEK

isoDayOfWeek

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> isoDayOfWeek(Temporal value)

Get the ISO day of week part of a date.

This is the same as calling extract(Temporal, DatePart) with DatePart.ISO_DAY_OF_WEEK

isoDayOfWeek

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> isoDayOfWeek(Field<?> field)

Get the ISO day of week part of a date.

This is the same as calling extract(Field, DatePart) with DatePart.ISO_DAY_OF_WEEK

dayOfYear

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> dayOfYear(Date value)

Get the day of week part of a date.

This is the same as calling extract(java.util.Date, DatePart) with DatePart.DAY_OF_YEAR

dayOfYear

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> dayOfYear(Temporal value)

Get the day of week part of a date.

This is the same as calling extract(Temporal, DatePart) with DatePart.DAY_OF_YEAR

dayOfYear

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
public static Field<Integer> dayOfYear(Field<?> field)

Get the day of week part of a date.

This is the same as calling extract(Field, DatePart) with DatePart.DAY_OF_YEAR

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

hour
```
@Support
public static Field<Integer> hour(Temporal value)
```
Get the hour part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.HOUR

hour
```
@Support
public static Field<Integer> hour(Field<?> field)
```
Get the hour part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.HOUR

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

minute
```
@Support
public static Field<Integer> minute(Temporal value)
```
Get the minute part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.MINUTE

minute
```
@Support
public static Field<Integer> minute(Field<?> field)
```
Get the minute part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MINUTE

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

second
```
@Support
public static Field<Integer> second(Temporal value)
```
Get the second part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.SECOND

second
```
@Support
public static Field<Integer> second(Field<?> field)
```
Get the second part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.SECOND

millisecond
```
@Support
public static Field<Integer> millisecond(Date value)
```
Get the millisecond part of a date.
This is the same as calling extract(java.util.Date, DatePart) with DatePart.MILLISECOND

millisecond
```
@Support
public static Field<Integer> millisecond(Temporal value)
```
Get the millisecond part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.MILLISECOND

millisecond
```
@Support
public static Field<Integer> millisecond(Field<?> field)
```
Get the millisecond part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MILLISECOND

microsecond
```
@Support
public static Field<Integer> microsecond(Date value)
```
Get the microsecond part of a date.
This is the same as calling extract(java.util.Date, DatePart) with DatePart.MICROSECOND

microsecond
```
@Support
public static Field<Integer> microsecond(Temporal value)
```
Get the microsecond part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.MICROSECOND

microsecond
```
@Support
public static Field<Integer> microsecond(Field<?> field)
```
Get the microsecond part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.MICROSECOND

timezone
```
@Support
public static Field<Integer> timezone(Date value)
```
Get the timezone part of a date.
This is the same as calling extract(java.util.Date, DatePart) with DatePart.TIMEZONE

timezone
```
@Support
public static Field<Integer> timezone(Temporal value)
```
Get the timezone part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.TIMEZONE

timezone
```
@Support
public static Field<Integer> timezone(Field<?> field)
```
Get the timezone part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.TIMEZONE

timezoneHour
```
@Support
public static Field<Integer> timezoneHour(Date value)
```
Get the timezoneHour part of a date.
This is the same as calling extract(java.util.Date, DatePart) with DatePart.TIMEZONE_HOUR

timezoneHour
```
@Support
public static Field<Integer> timezoneHour(Temporal value)
```
Get the timezoneHour part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.TIMEZONE_HOUR

timezoneHour
```
@Support
public static Field<Integer> timezoneHour(Field<?> field)
```
Get the timezoneHour part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.TIMEZONE_HOUR

timezoneMinute
```
@Support
public static Field<Integer> timezoneMinute(Date value)
```
Get the timezoneMinute part of a date.
This is the same as calling extract(java.util.Date, DatePart) with DatePart.TIMEZONE_MINUTE

timezoneMinute
```
@Support
public static Field<Integer> timezoneMinute(Temporal value)
```
Get the timezoneMinute part of a date.
This is the same as calling extract(Temporal, DatePart) with DatePart.TIMEZONE_MINUTE

timezoneMinute
```
@Support
public static Field<Integer> timezoneMinute(Field<?> field)
```
Get the timezoneMinute part of a date.
This is the same as calling extract(Field, DatePart) with DatePart.TIMEZONE_MINUTE

date

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Date> date(String value)

Convert a string value to a DATE.

date

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Date> date(Date value)

Convert a temporal value to a DATE.

date

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Date> date(Field<? extends Date> field)

Convert a temporal value to a DATE.

time

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Time> time(String value)

Convert a string value to a TIME.

time

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Time> time(Date value)

Convert a temporal value to a TIME.

time

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Time> time(Field<? extends Date> field)

Convert a temporal value to a TIME.

timestamp

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Timestamp> timestamp(String value)

Convert a string value to a TIMESTAMP.

timestamp

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Timestamp> timestamp(Date value)

Convert a temporal value to a TIMESTAMP.

timestamp

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<Timestamp> timestamp(Field<? extends Date> field)

Convert a temporal value to a TIMESTAMP.

localDate

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalDate> localDate(String value)

Convert a string value to a DATE.

localDate

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalDate> localDate(LocalDate value)

Convert a temporal value to a DATE.

localDate

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalDate> localDate(Field<LocalDate> field)

Convert a temporal value to a DATE.

localTime

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalTime> localTime(String value)

Convert a string value to a TIME.

localTime

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalTime> localTime(LocalTime value)

Convert a temporal value to a TIME.

localTime

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalTime> localTime(Field<LocalTime> field)

Convert a temporal value to a TIME.

localDateTime

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalDateTime> localDateTime(String value)

Convert a string value to a TIMESTAMP.

localDateTime

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalDateTime> localDateTime(LocalDateTime value)

Convert a temporal value to a TIMESTAMP.

localDateTime

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<LocalDateTime> localDateTime(Field<LocalDateTime> field)

Convert a temporal value to a TIMESTAMP.

offsetTime
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<OffsetTime> offsetTime(String value)
```
Convert a string value to a TIME WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

offsetTime
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<OffsetTime> offsetTime(OffsetTime value)
```
Convert a temporal value to a TIME WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

offsetTime
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<OffsetTime> offsetTime(Field<OffsetTime> field)
```
Convert a temporal value to a TIME WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

offsetDateTime
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<OffsetDateTime> offsetDateTime(String value)
```
Convert a string value to a TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

offsetDateTime
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<OffsetDateTime> offsetDateTime(OffsetDateTime value)
```
Convert a temporal value to a TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

offsetDateTime
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<OffsetDateTime> offsetDateTime(Field<OffsetDateTime> field)
```
Convert a temporal value to a TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

instant
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<Instant> instant(String value)
```
Convert a string value to a TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

instant
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<Instant> instant(Instant value)
```
Convert a temporal value to a TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

instant
```
@Support({AURORA_POSTGRES,H2,HSQLDB,ORACLE,POSTGRES,SQLITE})
public static Field<Instant> instant(Field<Instant> field)
```
Convert a temporal value to a TIMESTAMP WITH TIME ZONE.
Depending on whether the database preserves the time zone information (e.g. SQLDialect.ORACLE) or not (e.g. SQLDialect.POSTGRES), the resulting value might be converted to UTC. Regardless of this fact, the result should be the same Instant (in UTC) as the input.

toDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Date> toDate(String value,
                                 String format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Date> toDate(String value,
                                 Field<String> format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Date> toDate(Field<String> value,
                                 String format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Date> toDate(Field<String> value,
                                 Field<String> format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toTimestamp

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Timestamp> toTimestamp(String value,
                                           String format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toTimestamp

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Timestamp> toTimestamp(String value,
                                           Field<String> format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toTimestamp

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Timestamp> toTimestamp(Field<String> value,
                                           String format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toTimestamp

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<Timestamp> toTimestamp(Field<String> value,
                                           Field<String> format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toLocalDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDate> toLocalDate(String value,
                                           String format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toLocalDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDate> toLocalDate(String value,
                                           Field<String> format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toLocalDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDate> toLocalDate(Field<String> value,
                                           String format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toLocalDate

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDate> toLocalDate(Field<String> value,
                                           Field<String> format)

Parse a value to a DATE.

Parameters:: value - The formatted DATE value.; format - The vendor-specific formatting string.

toLocalDateTime

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDateTime> toLocalDateTime(String value,
                                                   String format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toLocalDateTime

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDateTime> toLocalDateTime(String value,
                                                   Field<String> format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toLocalDateTime

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDateTime> toLocalDateTime(Field<String> value,
                                                   String format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

toLocalDateTime

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,ORACLE,POSTGRES,VERTICA})
public static Field<LocalDateTime> toLocalDateTime(Field<String> value,
                                                   Field<String> format)

Parse a value to a TIMESTAMP.

Parameters:: value - The formatted TIMESTAMP value.; format - The vendor-specific formatting string.

rollup

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static GroupField rollup(Field<?>... fields)

Create a ROLLUP(field1, field2, .., fieldn) grouping field.

See Also:: rollup(FieldOrRow...)

rollup
```
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static GroupField rollup(FieldOrRow... fields)
```
Create a ROLLUP(field1, field2, .., fieldn) grouping field.
This has been observed to work with the following databases:
- CUBRID (emulated using the GROUP BY .. WITH ROLLUP clause)
- DB2
- MySQL (emulated using the GROUP BY .. WITH ROLLUP clause)
- Oracle
- PostgreSQL 9.5
- SQL Server
- Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of CUBE, ROLLUP, and GROUPING SETS clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
Parameters:

fields - The fields that are part of the ROLLUP function

Returns:

A field to be used in a GROUP BY clause

cube

@Support({AURORA_POSTGRES,DB2,HANA,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA})
public static GroupField cube(Field<?>... fields)

Create a CUBE(field1, field2, .., fieldn) grouping field.

See Also:: cube(Field...)

cube
```
@Support({AURORA_POSTGRES,DB2,HANA,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA})
public static GroupField cube(FieldOrRow... fields)
```
Create a CUBE(field1, field2, .., fieldn) grouping field.
This has been observed to work with the following databases:
- DB2
- Oracle
- PostgreSQL 9.5
- SQL Server
- Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of CUBE, ROLLUP, and GROUPING SETS clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
Parameters:

fields - The fields that are part of the CUBE function

Returns:

A field to be used in a GROUP BY clause

groupingSets
```
@Support({AURORA_POSTGRES,DB2,HANA,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA})
public static GroupField groupingSets(Field<?>... fields)
```
Create a GROUPING SETS(field1, field2, .., fieldn) grouping field where each grouping set only consists of a single field.
This has been observed to work with the following databases:
- DB2
- Oracle
- PostgreSQL 9.5
- SQL Server
- Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of CUBE, ROLLUP, and GROUPING SETS clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
Parameters:

fields - The fields that are part of the GROUPING SETS function

Returns:

A field to be used in a GROUP BY clause

groupingSets
```
@Support({AURORA_POSTGRES,DB2,HANA,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA})
public static GroupField groupingSets(Field<?>[]... fieldSets)
```
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna, fieldnb)) grouping field.
This has been observed to work with the following databases:
- DB2
- Oracle
- PostgreSQL 9.5
- SQL Server
- Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of CUBE, ROLLUP, and GROUPING SETS clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
Parameters:

fieldSets - The fields that are part of the GROUPING SETS function

Returns:

A field to be used in a GROUP BY clause

groupingSets
```
@Support({AURORA_POSTGRES,DB2,HANA,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA})
public static GroupField groupingSets(Collection<? extends Field<?>>... fieldSets)
```
Create a GROUPING SETS((field1a, field1b), (field2a), .., (fieldna, fieldnb)) grouping field.
This has been observed to work with the following databases:
- DB2
- Oracle
- PostgreSQL 9.5
- SQL Server
- Sybase SQL Anywhere
Please check the SQL Server documentation for a very nice explanation of CUBE, ROLLUP, and GROUPING SETS clauses in grouping contexts: http://msdn.microsoft.com/en-US/library/bb522495.aspx
Parameters:

fieldSets - The fields that are part of the GROUPING SETS function

Returns:

A field to be used in a GROUP BY clause

groupId
```
@Support(ORACLE)
@Pro
public static Field<Integer> groupId()
```
Create a GROUP_ID() aggregation function to be used along with CUBE, ROLLUP, and GROUPING SETS groupings.

Returns:

The GROUPING aggregation field

See Also:

cube(Field...), rollup(Field...)

grouping
```
@Support({AURORA_POSTGRES,DB2,HANA,MEMSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA})
public static Field<Integer> grouping(Field<?> field)
```
Create a GROUPING(field) aggregation field to be used along with CUBE, ROLLUP, and GROUPING SETS groupings.
This has been observed to work with the following databases:
- DB2
- Oracle
- PostgreSQL 9.5
- SQL Server
- Sybase SQL Anywhere
Parameters:

field - The function argument

Returns:

The GROUPING aggregation field

See Also:

cube(Field...), rollup(Field...)

groupingId
```
@Support({HANA,ORACLE,SQLSERVER})
public static Field<Integer> groupingId(Field<?>... fields)
```
Create a GROUPING_ID(field1, field2, .., fieldn) aggregation field to be used along with CUBE, ROLLUP, and GROUPING SETS groupings.
This has been observed to work with the following databases:
- Oracle
- SQL Server
Parameters:

fields - The function arguments

Returns:

The GROUPING_ID aggregation field

See Also:

cube(Field...), rollup(Field...)

bitCount

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SYBASE,TERADATA,VERTICA})
public static Field<Integer> bitCount(Number value)

The MySQL BIT_COUNT(field) function, counting the number of bits that are set in this number.

See Also:: bitCount(Field)

bitCount

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SYBASE,TERADATA,VERTICA})
public static Field<Integer> bitCount(Field<? extends Number> field)

The MySQL BIT_COUNT(field) function, counting the number of bits that are set in this number.

This function is emulated in most other databases like this (for a TINYINT field):

 ([field] &   1) +
 ([field] &   2) >> 1 +
 ([field] &   4) >> 2 +
 ([field] &   8) >> 3 +
 ([field] &  16) >> 4 +
  ...
 ([field] & 128) >> 7

More efficient algorithms are very welcome

bitNot

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNot(T value)

The bitwise not operator.

See Also:: bitNot(Field)

bitNot

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNot(Field<T> field)

The bitwise not operator.

Most dialects natively support this using ~[field]. jOOQ emulates this operator in some dialects using -[field] - 1

bitAnd

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitAnd(T value1,
                                                 T value2)

The bitwise and operator.

See Also:: bitAnd(Field, Field)

bitAnd

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitAnd(T value1,
                                                 Field<T> value2)

The bitwise and operator.

See Also:: bitAnd(Field, Field)

bitAnd

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitAnd(Field<T> value1,
                                                 T value2)

The bitwise and operator.

See Also:: bitAnd(Field, Field)

bitAnd

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitAnd(Field<T> field1,
                                                 Field<T> field2)

The bitwise and operator.

This is not supported by Derby, Ingres

This renders the and operation where available:

[field1] & [field2]

... or the and function elsewhere: bitand([field1], [field2])

bitNand

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNand(T value1,
                                                  T value2)

The bitwise not and operator.

See Also:: bitNand(Field, Field), bitNot(Field)

bitNand

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNand(T value1,
                                                  Field<T> value2)

The bitwise not and operator.

See Also:: bitNand(Field, Field), bitNot(Field)

bitNand

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNand(Field<T> value1,
                                                  T value2)

The bitwise not and operator.

See Also:: bitNand(Field, Field), bitNot(Field)

bitNand

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNand(Field<T> field1,
                                                  Field<T> field2)

The bitwise not and operator.

This is not supported by Derby, Ingres

This renders the not and operation where available:

~([field1] & [field2])

... or the not and function elsewhere: bitnot(bitand([field1], [field2]))

See Also:: bitNot(Field)

bitOr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitOr(T value1,
                                                T value2)

The bitwise or operator.

See Also:: bitOr(Field, Field)

bitOr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitOr(T value1,
                                                Field<T> value2)

The bitwise or operator.

See Also:: bitOr(Field, Field)

bitOr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitOr(Field<T> value1,
                                                T value2)

The bitwise or operator.

See Also:: bitOr(Field, Field)

bitOr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitOr(Field<T> field1,
                                                Field<T> field2)

The bitwise or operator.

This is not supported by Derby, Ingres

This renders the or operation where available:

[field1] | [field2]

... or the or function elsewhere: bitor([field1], [field2])

bitNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNor(T value1,
                                                 T value2)

The bitwise not or operator.

See Also:: bitNor(Field, Field), bitNot(Field)

bitNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNor(T value1,
                                                 Field<T> value2)

The bitwise not or operator.

See Also:: bitNor(Field, Field), bitNot(Field)

bitNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNor(Field<T> value1,
                                                 T value2)

The bitwise not or operator.

See Also:: bitNor(Field, Field), bitNot(Field)

bitNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitNor(Field<T> field1,
                                                 Field<T> field2)

The bitwise not or operator.

This is not supported by Derby, Ingres

This renders the not or operation where available:

~([field1] | [field2])

... or the not or function elsewhere: bitnot(bitor([field1], [field2]))

See Also:: bitNot(Field)

bitXor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXor(T value1,
                                                 T value2)

The bitwise xor operator.

See Also:: bitXor(Field, Field)

bitXor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXor(T value1,
                                                 Field<T> value2)

The bitwise xor operator.

See Also:: bitXor(Field, Field)

bitXor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXor(Field<T> value1,
                                                 T value2)

The bitwise xor operator.

See Also:: bitXor(Field, Field)

bitXor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXor(Field<T> field1,
                                                 Field<T> field2)

The bitwise xor operator.

This is not supported by Derby, Ingres

This renders the or operation where available:

[field1] ^ [field2]

... or the xor function elsewhere: bitxor([field1], [field2])

bitXNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXNor(T value1,
                                                  T value2)

The bitwise not xor operator.

See Also:: bitXNor(Field, Field), bitNot(Field)

bitXNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXNor(T value1,
                                                  Field<T> value2)

The bitwise not xor operator.

See Also:: bitXNor(Field, Field), bitNot(Field)

bitXNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXNor(Field<T> value1,
                                                  T value2)

The bitwise not xor operator.

See Also:: bitXNor(Field, Field), bitNot(Field)

bitXNor

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> bitXNor(Field<T> field1,
                                                  Field<T> field2)

The bitwise not xor operator.

This is not supported by Derby, Ingres

This renders the or operation where available:

~([field1] ^ [field2])

... or the not xor function elsewhere: bitnot(bitxor([field1], [field2]))

shl

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shl(T value1,
                                              Number value2)

The bitwise left shift operator.

See Also:: shl(Field, Field), power(Field, Number)

shl

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shl(T value1,
                                              Field<? extends Number> value2)

The bitwise left shift operator.

See Also:: shl(Field, Field), power(Field, Number)

shl

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shl(Field<T> value1,
                                              Number value2)

The bitwise left shift operator.

See Also:: shl(Field, Field), power(Field, Number)

shl

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shl(Field<T> field1,
                                              Field<? extends Number> field2)

The bitwise left shift operator.

Some dialects natively support this using [field1] << [field2]. jOOQ emulates this operator in some dialects using [field1] * power(2, [field2]), where power might also be emulated.

See Also:: power(Field, Field)

shr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shr(T value1,
                                              Number value2)

The bitwise right shift operator.

See Also:: shr(Field, Field), power(Field, Number)

shr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shr(T value1,
                                              Field<? extends Number> value2)

The bitwise right shift operator.

See Also:: shr(Field, Field), power(Field, Number)

shr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shr(Field<T> value1,
                                              Number value2)

The bitwise right shift operator.

See Also:: shr(Field, Field), power(Field, Number)

shr

@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> shr(Field<T> field1,
                                              Field<? extends Number> field2)

The bitwise right shift operator.

Some dialects natively support this using [field1] >> [field2]. jOOQ emulates this operator in some dialects using [field1] / power(2, [field2]), where power might also be emulated.

See Also:: power(Field, Field)

rand

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> rand()

Get the rand() function.

greatest
```
@Support
public static <T> Field<T> greatest(T value,
                                    T... values)
```
Find the greatest among all values.
This function has no equivalent in Adaptive Server, Derby, SQL Server and Sybase SQL Anywhere. Its current simulation implementation has O(2^n) complexity and should be avoided for n > 5! Better implementation suggestions are very welcome.

See Also:

greatest(Field, Field...)

greatest
```
@Support
public static <T> Field<T> greatest(Field<T> field,
                                    Field<?>... others)
```
Find the greatest among all values.
This function has no equivalent in Adaptive Server, Derby, SQL Server and Sybase SQL Anywhere. Its current simulation implementation has O(2^n) complexity and should be avoided for n > 5! Better implementation suggestions are very welcome.

least
```
@Support
public static <T> Field<T> least(T value,
                                 T... values)
```
Find the least among all values.
This function has no equivalent in Adaptive Server, Derby, SQL Server and Sybase SQL Anywhere. Its current simulation implementation has O(2^n) complexity and should be avoided for n > 5! Better implementation suggestions are very welcome.

See Also:

least(Field, Field...)

least
```
@Support
public static <T> Field<T> least(Field<T> field,
                                 Field<?>... others)
```
Find the least among all values.
This function has no equivalent in Adaptive Server, Derby, SQL Server and Sybase SQL Anywhere. Its current simulation implementation has O(2^n) complexity and should be avoided for n > 5! Better implementation suggestions are very welcome.

neg

@Support
public static <T extends Number> Field<T> neg(Field<T> field)

Negate a field to get its negative value.

See Also:: Field.neg()

minus

@Support
public static <T extends Number> Field<T> minus(Field<T> field)

Negate a field to get its negative value.

See Also:: Field.neg()

sign
```
@Support
public static Field<Integer> sign(Number value)
```
Get the sign of a numeric field: sign(field).

See Also:

sign(Field)

sign

@Support
public static Field<Integer> sign(Field<? extends Number> field)

Get the sign of a numeric field: sign(field).

This renders the sign function where available:

sign([field])

... or emulates it elsewhere (without bind variables on values -1, 0, 1):

 CASE WHEN [this] > 0 THEN 1
      WHEN [this] < 0 THEN -1
      ELSE 0
 END









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

See Also:
abs(Field)








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









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

See Also:
round(Field)








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









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

See Also:
round(Field, int)








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









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

See Also:
floor(Field)








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









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

See Also:
ceil(Field)








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









trunc
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> trunc(T number)
Truncate a number to a given number of decimals.

See Also:
trunc(Field, Field)










trunc
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> trunc(T number,
                                                int decimals)
Truncate a number to a given number of decimals.

See Also:
trunc(Field, Field)








trunc
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> trunc(Field<T> number,
                                                int decimals)
Truncate a number to a given number of decimals.

See Also:
trunc(Field, Field)










trunc
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static <T extends Number> Field<T> trunc(T number,
                                                Field<Integer> decimals)
Truncate a number to a given number of decimals.

See Also:
trunc(Field, Field)








trunc
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA})
public static <T extends Number> Field<T> trunc(Field<T> number,
                                                Field<Integer> decimals)
Truncate a number to a given number of decimals.
 
 This function truncates number to the amount of decimals
 specified in decimals. Passing decimals = 0 to
 this function is the same as using floor(Field). Passing
 positive values for decimal has a similar effect as
 round(Field, int). Passing negative values for
 decimal will truncate number to a given power
 of 10. Some examples
 

 
 Function call
 yields...
 
 
 trunc(125.815)
 125
 
 
 trunc(125.815, 0)
 125
 
 
 trunc(125.815, 1)
 125.8
 
 
 trunc(125.815, 2)
 125.81
 
 
 trunc(125.815, -1)
 120
 
 
 trunc(125.815, -2)
 100
 
 

See Also:
trunc(Field, Field)








sqrt
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> sqrt(Number value)
Get the sqrt(field) function.

See Also:
sqrt(Field)








sqrt
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> sqrt(Field<? extends Number> field)
Get the sqrt(field) function.
 
 This renders the sqrt function where available:
 
sqrt([field]) ... or emulates it elsewhere using
 power (which in turn may also be emulated using ln and exp functions):
 power([field], 0.5)







exp
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> exp(Number value)
Get the exp(field) function, taking this field as the power of e.

See Also:
exp(Field)








exp
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> exp(Field<? extends Number> field)
Get the exp(field) function, taking this field as the power of e.
 
 This renders the same on all dialects:
 
exp([field])







ln
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> ln(Number value)
Get the ln(field) function, taking the natural logarithm of this field.

See Also:
ln(Field)








ln
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> ln(Field<? extends Number> field)
Get the ln(field) function, taking the natural logarithm of this field.
 
 This renders the ln or log function where available:
 
ln([field]) or
 log([field])







log
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> log(Number value,
                                    int base)
Get the log(field, base) function.

See Also:
log(Field, int)








log
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> log(Field<? extends Number> field,
                                    int base)
Get the log(field, base) function.
 
 This renders the log function where available:
 
log([field]) ... or emulates it elsewhere (in
 most RDBMS) using the natural logarithm:
 ln([field]) / ln([base])







log
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> log(Field<? extends Number> field,
                                    Field<? extends Number> base)
Get the log(field, base) function.
 
 This renders the log function where available:
 
log([field]) ... or emulates it elsewhere (in
 most RDBMS) using the natural logarithm:
 ln([field]) / ln([base])







power
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> power(Number value,
                                      Number exponent)
Get the power(field, exponent) function.

See Also:
power(Field, Field)








power
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> power(Field<? extends Number> field,
                                      Number exponent)
Get the power(field, exponent) function.

See Also:
power(Field, Field)








power
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> power(Number value,
                                      Field<? extends Number> exponent)
Get the power(field, exponent) function.

See Also:
power(Field, Field)








power
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> power(Field<? extends Number> field,
                                      Field<? extends Number> exponent)
Get the power(field, exponent) function.
 
 This renders the power function where available:
 
power([field], [exponent]) ... or emulates it
 elsewhere using ln and exp:
 exp(ln([field]) * [exponent])







acos
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> acos(Number value)
Get the arc cosine(field) function.

See Also:
acos(Field)








acos
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> acos(Field<? extends Number> field)
Get the arc cosine(field) function.
 
 This renders the acos function where available:
 
acos([field])







asin
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> asin(Number value)
Get the arc sine(field) function.

See Also:
asin(Field)








asin
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> asin(Field<? extends Number> field)
Get the arc sine(field) function.
 
 This renders the asin function where available:
 
asin([field])







atan
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> atan(Number value)
Get the arc tangent(field) function.

See Also:
atan(Field)








atan
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> atan(Field<? extends Number> field)
Get the arc tangent(field) function.
 
 This renders the atan function where available:
 
atan([field])







atan2
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> atan2(Number x,
                                      Number y)
Get the atan2(field, y) function.

See Also:
atan2(Field, Field)








atan2
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> atan2(Number x,
                                      Field<? extends Number> y)
Get the atan2(field, y) function.

See Also:
atan2(Field, Field)








atan2
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> atan2(Field<? extends Number> x,
                                      Number y)
Get the atan2(field, y) function.

See Also:
atan2(Field, Field)








atan2
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> atan2(Field<? extends Number> x,
                                      Field<? extends Number> y)
Get the atan2(field, y) function.
 
 This renders the atan2 or atn2 function where available:
 
atan2([x], [y]) or
 atn2([x], [y])







cos
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> cos(Number value)
Get the cosine(field) function.

See Also:
cos(Field)








cos
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> cos(Field<? extends Number> field)
Get the cosine(field) function.
 
 This renders the cos function where available:
 
cos([field])







sin
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> sin(Number value)
Get the sine(field) function.

See Also:
sin(Field)








sin
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> sin(Field<? extends Number> field)
Get the sine(field) function.
 
 This renders the sin function where available:
 
sin([field])







tan
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> tan(Number value)
Get the tangent(field) function.

See Also:
tan(Field)








tan
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> tan(Field<? extends Number> field)
Get the tangent(field) function.
 
 This renders the tan function where available:
 
tan([field])







cot
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> cot(Number value)
Get the cotangent(field) function.

See Also:
cot(Field)








cot
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> cot(Field<? extends Number> field)
Get the cotangent(field) function.
 
 This renders the cot function where available:
 
cot([field]) ... or emulates it elsewhere using
 sin and cos: cos([field]) / sin([field])







sinh
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> sinh(Number value)
Get the hyperbolic sine function: sinh(field).

See Also:
sinh(Field)








sinh
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> sinh(Field<? extends Number> field)
Get the hyperbolic sine function: sinh(field).
 
 This renders the sinh function where available:
 
sinh([field]) ... or emulates it elsewhere using
 exp: (exp([field] * 2) - 1) / (exp([field] * 2))







cosh
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> cosh(Number value)
Get the hyperbolic cosine function: cosh(field).

See Also:
cosh(Field)








cosh
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> cosh(Field<? extends Number> field)
Get the hyperbolic cosine function: cosh(field).
 
 This renders the cosh function where available:
 
cosh([field]) ... or emulates it elsewhere using
 exp: (exp([field] * 2) + 1) / (exp([field] * 2))







tanh
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> tanh(Number value)
Get the hyperbolic tangent function: tanh(field).

See Also:
tanh(Field)








tanh
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> tanh(Field<? extends Number> field)
Get the hyperbolic tangent function: tanh(field).
 
 This renders the tanh function where available:
 
tanh([field]) ... or emulates it elsewhere using
 exp:
 (exp([field] * 2) - 1) / (exp([field] * 2) + 1)







coth
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> coth(Number value)
Get the hyperbolic cotangent function: coth(field).

See Also:
coth(Field)








coth
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static Field<BigDecimal> coth(Field<? extends Number> field)
Get the hyperbolic cotangent function: coth(field).
 
 This is not supported by any RDBMS, but emulated using exp exp:
 
(exp([field] * 2) + 1) / (exp([field] * 2) - 1)







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

See Also:
deg(Field)








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







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

See Also:
rad(Field)








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







level
@Support({CUBRID,INFORMIX,ORACLE})
public static Field<Integer> level()
Retrieve the Oracle-specific LEVEL pseudo-field (to be used
 along with CONNECT BY clauses).







connectByIsCycle
@Support({CUBRID,INFORMIX,ORACLE})
public static Field<Boolean> connectByIsCycle()
Retrieve the Oracle-specific CONNECT_BY_ISCYCLE pseudo-field
 (to be used along with CONNECT BY clauses).







connectByIsLeaf
@Support({CUBRID,INFORMIX,ORACLE})
public static Field<Boolean> connectByIsLeaf()
Retrieve the Oracle-specific CONNECT_BY_ISLEAF pseudo-field
 (to be used along with CONNECT BY clauses).







connectByRoot
@Support({CUBRID,INFORMIX,ORACLE})
public static <T> Field<T> connectByRoot(Field<T> field)
Retrieve the Oracle-specific CONNECT_BY_ROOT pseudo-column
 (to be used along with CONNECT BY clauses).







sysConnectByPath
@Support({CUBRID,INFORMIX,ORACLE})
public static Field<String> sysConnectByPath(Field<?> field,
                                             String separator)
Retrieve the Oracle-specific
 SYS_CONNECT_BY_PATH(field, separator) function (to be used
 along with CONNECT BY clauses).







prior
@Support({CUBRID,INFORMIX,ORACLE})
public static <T> Field<T> prior(Field<T> field)
Add the Oracle-specific PRIOR unary operator before a field
 (to be used along with CONNECT BY clauses).







rownum
@Support({CUBRID,ORACLE})
public static Field<Integer> rownum()
Retrieve the Oracle-specific ROWNUM pseudo-field.







jsonArray
@Support({MYSQL_5_7,ORACLE12C,POSTGRES})
public static Field<JSON> jsonArray(Field<?>... fields)
The JSON array constructor.







jsonArray
@Support({MYSQL_5_7,ORACLE12C,POSTGRES})
public static Field<JSON> jsonArray(Collection<? extends Field<?>> fields)
The JSON array constructor.







jsonbArray
@Support({MYSQL_5_7,ORACLE12C,POSTGRES})
public static Field<JSONB> jsonbArray(Field<?>... fields)
The JSONB array constructor.







jsonbArray
@Support({MYSQL_5_7,ORACLE12C,POSTGRES})
public static Field<JSONB> jsonbArray(Collection<? extends Field<?>> fields)
The JSONB array constructor.







jsonEntry
@Support({MYSQL_5_7,ORACLE12C,POSTGRES,SQLSERVER})
public static <T> JSONEntry<T> jsonEntry(Field<String> key,
                                         Field<T> value)
A constructor for JSON entries to be used with jsonObject(JSONEntry...).







jsonObject
@Support({MYSQL_5_7,ORACLE12C,POSTGRES,SQLSERVER2016})
public static Field<JSON> jsonObject(Field<String> key,
                                     Field<?> value)
The JSON object constructor.







jsonObject
@Support({MYSQL_5_7,ORACLE12C,POSTGRES,SQLSERVER2016})
public static Field<JSON> jsonObject(JSONEntry<?>... entries)
The JSON object constructor.







jsonObject
@Support({MYSQL_5_7,ORACLE12C,POSTGRES,SQLSERVER2016})
public static Field<JSON> jsonObject(Collection<? extends JSONEntry<?>> entries)
The JSON object constructor.







jsonbObject
@Support({MYSQL_5_7,ORACLE12C,POSTGRES,SQLSERVER2016})
public static Field<JSONB> jsonbObject(JSONEntry<?>... entries)
The JSONB object constructor.







jsonbObject
@Support({MYSQL_5_7,ORACLE12C,POSTGRES,SQLSERVER2016})
public static Field<JSONB> jsonbObject(Collection<? extends JSONEntry<?>> entries)
The JSONB object constructor.







count
@Support
public static AggregateFunction<Integer> count()
Get the count(*) function.







count
@Support
public static AggregateFunction<Integer> count(Field<?> field)
Get the count(field) function.







count
@Support
public static AggregateFunction<Integer> count(SelectFieldOrAsterisk field)
Get the count(field) function.







count
@Support
public static AggregateFunction<Integer> count(Table<?> table)
Get the count(table) function.
 
 If this is not supported by a given database (i.e. non
 SQLDialect.POSTGRES, then the primary key is used with
 count(Field), instead.







countDistinct
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static AggregateFunction<Integer> countDistinct(Field<?> field)
Get the count(distinct field) function.







countDistinct
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static AggregateFunction<Integer> countDistinct(SelectFieldOrAsterisk field)
Get the count(distinct field) function.







countDistinct
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static AggregateFunction<Integer> countDistinct(Table<?> table)
Get the count(distinct table) function.
 
 If this is not supported by a given database (i.e. non
 SQLDialect.POSTGRES, then the primary key is used with
 count(Field), instead.







countDistinct
@Support({AURORA_MYSQL,AURORA_POSTGRES,HSQLDB,MEMSQL,MYSQL,POSTGRES})
public static AggregateFunction<Integer> countDistinct(Field<?>... fields)
Get the count(distinct field1, field2) function.
 
 Some dialects support several expressions in the
 COUNT(DISTINCT expr1, expr2) aggregate function.
 

 SQLDialect.POSTGRES supports this as
 COUNT(DISTINCT(expr1, expr2)).







every
@Support
public static AggregateFunction<Boolean> every(Field<Boolean> field)
Get the every value over a field: every(field).
 
 This is a synonym for boolAnd(Field).







every
@Support
public static AggregateFunction<Boolean> every(Condition condition)
Get the every value over a condition: every(condition).
 
 This is a synonym for boolAnd(Condition).







boolAnd
@Support
public static AggregateFunction<Boolean> boolAnd(Field<Boolean> field)
Get the every value over a field: bool_and(field).







boolAnd
@Support
public static AggregateFunction<Boolean> boolAnd(Condition condition)
Get the every value over a condition: bool_and(condition).







boolOr
@Support
public static AggregateFunction<Boolean> boolOr(Field<Boolean> field)
Get the every value over a field: bool_and(field).







boolOr
@Support
public static AggregateFunction<Boolean> boolOr(Condition condition)
Get the every value over a condition: bool_and(condition).







arrayAgg
@Support({AURORA_POSTGRES,HSQLDB,POSTGRES})
public static <T> ArrayAggOrderByStep<T[]> arrayAgg(Field<T> field)
Get the array_agg() aggregate function.







arrayAggDistinct
@Support({AURORA_POSTGRES,HSQLDB,POSTGRES})
public static <T> ArrayAggOrderByStep<T[]> arrayAggDistinct(Field<T> field)
Get the array_agg() aggregate function.







collect
@Support(ORACLE)
@Pro
public static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A> collect(Field<T> field,
                                                                                Class<A> type)
Get the collect() aggregate function.
 
 In Oracle, a standalone collect() expression generates an
 anonymous collection type, which can be used by clients only if cast
 explicitly to a user-defined collection type. The latter can be supplied
 here for convenience as the second argument.







collect
@Support(ORACLE)
@Pro
public static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A> collect(Field<T> field,
                                                                                DataType<A> type)
Get the collect() aggregate function.
 
 In Oracle, a standalone collect() expression generates an
 anonymous collection type, which can be used by clients only if cast
 explicitly to a user-defined collection type. The latter can be supplied
 here for convenience as the second argument.







collectDistinct
@Support(ORACLE)
@Pro
public static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A> collectDistinct(Field<T> field,
                                                                                        Class<A> type)
Get the collect() aggregate function.
 
 In Oracle, a standalone collect() expression generates an
 anonymous collection type, which can be used by clients only if cast
 explicitly to a user-defined collection type. The latter can be supplied
 here for convenience as the second argument.







collectDistinct
@Support(ORACLE)
@Pro
public static <T,A extends ArrayRecord<T>> ArrayAggOrderByStep<A> collectDistinct(Field<T> field,
                                                                                        DataType<A> type)
Get the collect() aggregate function.
 
 In Oracle, a standalone collect() expression generates an
 anonymous collection type, which can be used by clients only if cast
 explicitly to a user-defined collection type. The latter can be supplied
 here for convenience as the second argument.









array
@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES})
public static <T> Field<T[]> array(T... values)
Create an array literal.
 
 This translates to the following databases and syntaxes:
 

 
 SQLDialect
 Java
 SQL
 
 
 SQLDialect.H2
 array(1, 2)
 (1, 2)
 
 
 SQLDialect.HSQLDB, SQLDialect.POSTGRES
 array(1, 2)
 array[1, 2]
 
 







array
@SafeVarargs
@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES})
public static <T> Field<T[]> array(Field<T>... fields)
Create an array literal.
 
 This translates to the following databases and syntaxes:
 

 
 SQLDialect
 Java
 SQL
 
 
 SQLDialect.H2
 array(1, 2)
 (1, 2)
 
 
 SQLDialect.HSQLDB, SQLDialect.POSTGRES
 array(1, 2)
 array[1, 2]
 
 







array
@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES})
public static <T> Field<T[]> array(Collection<? extends Field<T>> fields)
Create an array literal.
 
 This translates to the following databases and syntaxes:
 

 
 SQLDialect
 Java
 SQL
 
 
 SQLDialect.H2
 array(1, 2)
 (1, 2)
 
 
 SQLDialect.HSQLDB, SQLDialect.POSTGRES
 array(1, 2)
 array[1, 2]
 
 







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







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







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







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







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







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







product
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> product(Field<? extends Number> field)
Get the product over a numeric field: product(field).
 
 No database currently supports multiplicative aggregation natively. jOOQ
 emulates this using exp(sum(log(arg))) for strictly positive
 numbers, and does some additional handling for zero and negative numbers.
 

 Note that this implementation may introduce rounding errors, even for
 integer multiplication.
 

 More information here: https://blog.jooq.org/2018/09/21/how-to-write-a-multiplication-aggregate-function-in-sql.







productDistinct
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> productDistinct(Field<? extends Number> field)
Get the sum over a numeric field: product(distinct field).
 
 No database currently supports multiplicative aggregation natively. jOOQ
 emulates this using exp(sum(log(arg))) for strictly positive
 numbers, and does some additional handling for zero and negative numbers.
 

 Note that this implementation may introduce rounding errors, even for
 integer multiplication.
 

 More information here: https://blog.jooq.org/2018/09/21/how-to-write-a-multiplication-aggregate-function-in-sql.







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







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







mode
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static <T> AggregateFunction<T> mode(Field<T> field)
The mode(field) aggregate function.







median
@Support({AURORA_POSTGRES,CUBRID,H2,HSQLDB,MARIADB,ORACLE,POSTGRES_9_4,SYBASE,TERADATA})
public static AggregateFunction<BigDecimal> median(Field<? extends Number> field)
Get the median over a numeric field: median(field).







stddevPop
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> stddevPop(Field<? extends Number> field)
Get the population standard deviation of a numeric field: stddev_pop(field).







stddevSamp
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> stddevSamp(Field<? extends Number> field)
Get the sample standard deviation of a numeric field: stddev_samp(field).







varPop
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> varPop(Field<? extends Number> field)
Get the population variance of a numeric field: var_pop(field).







varSamp
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> varSamp(Field<? extends Number> field)
Get the sample variance of a numeric field: var_samp(field).







regrSlope
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrSlope(Field<? extends Number> y,
                                                      Field<? extends Number> x)
Get the REGR_SLOPE linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrIntercept
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrIntercept(Field<? extends Number> y,
                                                          Field<? extends Number> x)
Get the REGR_INTERCEPT linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrCount
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrCount(Field<? extends Number> y,
                                                      Field<? extends Number> x)
Get the REGR_COUNT linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrR2
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrR2(Field<? extends Number> y,
                                                   Field<? extends Number> x)
Get the REGR_R2 linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrAvgX
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrAvgX(Field<? extends Number> y,
                                                     Field<? extends Number> x)
Get the REGR_AVGX linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrAvgY
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrAvgY(Field<? extends Number> y,
                                                     Field<? extends Number> x)
Get the REGR_AVGY linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrSXX
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrSXX(Field<? extends Number> y,
                                                    Field<? extends Number> x)
Get the REGR_SXX linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrSYY
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrSYY(Field<? extends Number> y,
                                                    Field<? extends Number> x)
Get the REGR_SYY linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







regrSXY
@Support({AURORA_POSTGRES,DB2,ORACLE,POSTGRES,SYBASE,TERADATA,VERTICA})
public static AggregateFunction<BigDecimal> regrSXY(Field<? extends Number> y,
                                                    Field<? extends Number> x)
Get the REGR_SXY linear regression function.
 
 The linear regression functions fit an ordinary-least-squares regression
 line to a set of number pairs. You can use them as both aggregate and
 window functions, where this is supported.
 

 Note that SQLDialect.DB2 does not support linear regression
 window functions.







listAgg
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,MARIADB,MYSQL,ORACLE11G,POSTGRES,SYBASE})
public static OrderedAggregateFunction<String> listAgg(Field<?> field)
Get the aggregated concatenation for a field.
 
 This is natively supported by SQLDialect.ORACLE11G upwards. It is
 emulated by the following dialects:
 

  SQLDialect.AURORA_MYSQL: Using GROUP_CONCAT
  SQLDialect.CUBRID: Using GROUP_CONCAT()
  SQLDialect.DB2: Using XMLAGG()
  SQLDialect.H2: Using GROUP_CONCAT()
  SQLDialect.HSQLDB: Using GROUP_CONCAT()
  SQLDialect.MYSQL: Using GROUP_CONCAT()
  SQLDialect.POSTGRES: Using STRING_AGG()
  SQLDialect.SYBASE: Using LIST()
 

See Also:
groupConcat(Field)








listAgg
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,MARIADB,MYSQL,ORACLE11G,POSTGRES,SYBASE})
public static OrderedAggregateFunction<String> listAgg(Field<?> field,
                                                       String separator)
Get the aggregated concatenation for a field.
 
 This is natively supported by SQLDialect.ORACLE11G upwards. It is
 emulated by the following dialects:
 

  SQLDialect.AURORA_MYSQL: Using GROUP_CONCAT
  SQLDialect.CUBRID: Using GROUP_CONCAT
  SQLDialect.DB2: Using XMLAGG()
  SQLDialect.H2: Using GROUP_CONCAT
  SQLDialect.HSQLDB: Using GROUP_CONCAT
  SQLDialect.MYSQL: Using GROUP_CONCAT
  SQLDialect.POSTGRES: Using STRING_AGG()
  SQLDialect.SYBASE: Using LIST()
 

See Also:
groupConcat(Field)








groupConcat
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SYBASE})
public static GroupConcatOrderByStep groupConcat(Field<?> field)
Get the aggregated concatenation for a field.
 
 This is natively supported by
 

  SQLDialect.AURORA_MYSQL
  SQLDialect.CUBRID
  SQLDialect.H2
  SQLDialect.HSQLDB
  SQLDialect.MEMSQL (but without ORDER BY)
  SQLDialect.MYSQL
  SQLDialect.SQLITE (but without ORDER BY)
 
 
 It is emulated by the following dialects:
 

  SQLDialect.DB2: Using XMLAGG()
  SQLDialect.ORACLE: Using LISTAGG()
  SQLDialect.POSTGRES: Using STRING_AGG()
  SQLDialect.SYBASE: Using LIST()
 

See Also:
listAgg(Field)








groupConcat
@Deprecated
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SYBASE})
public static AggregateFunction<String> groupConcat(Field<?> field,
                                                    String separator)
Deprecated.
- [#7956] - 3.12.0 - Use groupConcat(Field) and
             GroupConcatSeparatorStep.separator(String) instead.

Get the aggregated concatenation for a field.
 
 This is natively supported by
 

 SQLDialect.AURORA_MYSQL
 SQLDialect.CUBRID
 SQLDialect.H2
 SQLDialect.HSQLDB
 SQLDialect.MEMSQL
 SQLDialect.MYSQL
 SQLDialect.SQLITE
 
 
 It is emulated by the following dialects:
 

 SQLDialect.DB2: Using XMLAGG()
 SQLDialect.ORACLE: Using LISTAGG()
 SQLDialect.POSTGRES: Using STRING_AGG()
 SQLDialect.SYBASE: Using LIST()
 

See Also:
listAgg(Field)








groupConcatDistinct
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SYBASE})
public static GroupConcatOrderByStep groupConcatDistinct(Field<?> field)
Get the aggregated concatenation for a field.
 
 This is natively supported by
 

  SQLDialect.AURORA_MYSQL
  SQLDialect.CUBRID
  SQLDialect.H2
  SQLDialect.HSQLDB
  SQLDialect.MYSQL
 
 
 It is emulated by the following dialects:
 

  SQLDialect.SYBASE: Using LIST()
  SQLDialect.POSTGRES: Using STRING_AGG()
 

See Also:
listAgg(Field)








mode
@Support({AURORA_POSTGRES,H2,POSTGRES_9_4})
public static OrderedAggregateFunctionOfDeferredType mode()
The mode() within group (oder by [order clause]) ordered
 aggregate function.







rank
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<Integer> rank(Field<?>... fields)
The rank(expr) within group (order by [order clause])
 ordered-set aggregate function.







rank
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<Integer> rank(Collection<? extends Field<?>> fields)
The rank(expr) within group (order by [order clause])
 ordered-set aggregate function.







denseRank
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<Integer> denseRank(Field<?>... fields)
The dense_rank(expr) within group (order by [order clause])
 ordered-set aggregate function.







denseRank
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<Integer> denseRank(Collection<? extends Field<?>> fields)
The dense_rank(expr) within group (order by [order clause])
 ordered-set aggregate function.







percentRank
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<Integer> percentRank(Field<?>... fields)
The percent_rank(expr) within group (order by [order clause])
 ordered-set aggregate function.







percentRank
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<Integer> percentRank(Collection<? extends Field<?>> fields)
The percent_rank(expr) within group (order by [order clause])
 ordered-set aggregate function.







cumeDist
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<BigDecimal> cumeDist(Field<?>... fields)
The cume_dist(expr) within group (order by [order clause])
 ordered-set aggregate function.







cumeDist
@Support({AURORA_POSTGRES,H2,ORACLE,POSTGRES_9_4})
public static OrderedAggregateFunction<BigDecimal> cumeDist(Collection<? extends Field<?>> fields)
The cume_dist(expr) within group (order by [order clause])
 ordered-set aggregate function.







percentileCont
@Support({AURORA_POSTGRES,H2,MEMSQL,ORACLE,POSTGRES_9_4,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER2012,TERADATA})
public static OrderedAggregateFunction<BigDecimal> percentileCont(Number number)
The
 percentile_cont([number]) within group (order by [column])
 function.
 
 While SQLDialect.ORACLE and SQLDialect.POSTGRES support
 this as an aggregate function, SQLDialect.SQLSERVER and
 SQLDialect.REDSHIFT support only its window function variant.







percentileCont
@Support({AURORA_POSTGRES,H2,MEMSQL,ORACLE,POSTGRES_9_4,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER2012,TERADATA})
public static OrderedAggregateFunction<BigDecimal> percentileCont(Field<? extends Number> field)
The
 percentile_cont([number]) within group (order by [column])
 function.
 
 While SQLDialect.ORACLE and SQLDialect.POSTGRES support
 this as an aggregate function, SQLDialect.SQLSERVER and
 SQLDialect.REDSHIFT support only its window function variant.







percentileDisc
@Support({AURORA_POSTGRES,H2,MEMSQL,ORACLE,POSTGRES_9_4,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER2012,TERADATA})
public static OrderedAggregateFunction<BigDecimal> percentileDisc(Number number)
The
 percentile_disc([number]) within group (order by [column])
 function.
 
 While SQLDialect.ORACLE and SQLDialect.POSTGRES support
 this as an aggregate function, SQLDialect.SQLSERVER and
 SQLDialect.REDSHIFT support only its window function variant.







percentileDisc
@Support({AURORA_POSTGRES,H2,MEMSQL,ORACLE,POSTGRES_9_4,REDSHIFT,SQLDATAWAREHOUSE,SQLSERVER2012,TERADATA})
public static OrderedAggregateFunction<BigDecimal> percentileDisc(Field<? extends Number> field)
The
 percentile_disc([number]) within group (order by [column])
 function.
 
 While SQLDialect.ORACLE and SQLDialect.POSTGRES support
 this as an aggregate function, SQLDialect.SQLSERVER and
 SQLDialect.REDSHIFT support only its window function variant.







partitionBy
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationOrderByStep partitionBy(Field<?>... fields)
Create a WindowSpecification with a PARTITION BY clause.







partitionBy
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationOrderByStep partitionBy(Collection<? extends Field<?>> fields)
Create a WindowSpecification with a PARTITION BY clause.







orderBy
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsStep orderBy(Field<?>... fields)
Create a WindowSpecification with an ORDER BY clause.







orderBy
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsStep orderBy(OrderField<?>... fields)
Create a WindowSpecification with an ORDER BY clause.







orderBy
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsStep orderBy(Collection<? extends OrderField<?>> fields)
Create a WindowSpecification with an ORDER BY clause.







rowsUnboundedPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rowsUnboundedPreceding()
Create a WindowSpecification with a ROWS clause.







rowsPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rowsPreceding(int number)
Create a WindowSpecification with a ROWS clause.







rowsCurrentRow
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rowsCurrentRow()
Create a WindowSpecification with a ROWS clause.







rowsUnboundedFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rowsUnboundedFollowing()
Create a WindowSpecification with a ROWS clause.







rowsFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rowsFollowing(int number)
Create a WindowSpecification with a ROWS clause.







rowsBetweenUnboundedPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rowsBetweenUnboundedPreceding()
Create a WindowSpecification with a ROWS clause.







rowsBetweenPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rowsBetweenPreceding(int number)
Create a WindowSpecification with a ROWS clause.







rowsBetweenCurrentRow
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rowsBetweenCurrentRow()
Create a WindowSpecification with a ROWS clause.







rowsBetweenUnboundedFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rowsBetweenUnboundedFollowing()
Create a WindowSpecification with a ROWS clause.







rowsBetweenFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rowsBetweenFollowing(int number)
Create a WindowSpecification with a ROWS clause.







rangeUnboundedPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rangeUnboundedPreceding()
Create a WindowSpecification with a RANGE clause.







rangePreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rangePreceding(int number)
Create a WindowSpecification with a RANGE clause.







rangeCurrentRow
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rangeCurrentRow()
Create a WindowSpecification with a RANGE clause.







rangeUnboundedFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rangeUnboundedFollowing()
Create a WindowSpecification with a RANGE clause.







rangeFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationExcludeStep rangeFollowing(int number)
Create a WindowSpecification with a RANGE clause.







rangeBetweenUnboundedPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rangeBetweenUnboundedPreceding()
Create a WindowSpecification with a RANGE clause.







rangeBetweenPreceding
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rangeBetweenPreceding(int number)
Create a WindowSpecification with a RANGE clause.







rangeBetweenCurrentRow
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rangeBetweenCurrentRow()
Create a WindowSpecification with a RANGE clause.







rangeBetweenUnboundedFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rangeBetweenUnboundedFollowing()
Create a WindowSpecification with a RANGE clause.







rangeBetweenFollowing
@Support({AURORA_POSTGRES,DB2,H2,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowSpecificationRowsAndStep rangeBetweenFollowing(int number)
Create a WindowSpecification with a RANGE clause.







groupsUnboundedPreceding
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationExcludeStep groupsUnboundedPreceding()
Create a WindowSpecification with a GROUPS clause.







groupsPreceding
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationExcludeStep groupsPreceding(int number)
Create a WindowSpecification with a GROUPS clause.







groupsCurrentRow
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationExcludeStep groupsCurrentRow()
Create a WindowSpecification with a GROUPS clause.







groupsUnboundedFollowing
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationExcludeStep groupsUnboundedFollowing()
Create a WindowSpecification with a GROUPS clause.







groupsFollowing
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationExcludeStep groupsFollowing(int number)
Create a WindowSpecification with a GROUPS clause.







groupsBetweenUnboundedPreceding
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationRowsAndStep groupsBetweenUnboundedPreceding()
Create a WindowSpecification with a GROUPS clause.







groupsBetweenPreceding
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationRowsAndStep groupsBetweenPreceding(int number)
Create a WindowSpecification with a GROUPS clause.







groupsBetweenCurrentRow
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationRowsAndStep groupsBetweenCurrentRow()
Create a WindowSpecification with a GROUPS clause.







groupsBetweenUnboundedFollowing
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationRowsAndStep groupsBetweenUnboundedFollowing()
Create a WindowSpecification with a GROUPS clause.







groupsBetweenFollowing
@Support({H2,POSTGRES_11,SQLITE_3_28})
public static WindowSpecificationRowsAndStep groupsBetweenFollowing(int number)
Create a WindowSpecification with a GROUPS clause.







rowNumber
@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowOverStep<Integer> rowNumber()
The row_number() over ([analytic clause]) function.
 
 Newer versions of SQLDialect.DERBY and SQLDialect.H2 also
 support the ROW_NUMBER() OVER() window function without any
 window clause. See the respective docs for details.
 SQLDialect.HSQLDB can emulate this function using
 ROWNUM()







rank
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowOverStep<Integer> rank()
The rank() over ([analytic clause]) function.







denseRank
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowOverStep<Integer> denseRank()
The dense_rank() over ([analytic clause]) function.







percentRank
@Support({AURORA_POSTGRES,CUBRID,DB2_11,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA,VERTICA})
public static WindowOverStep<BigDecimal> percentRank()
The precent_rank() over ([analytic clause]) function.







cumeDist
@Support({AURORA_POSTGRES,CUBRID,DB2_11,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
public static WindowOverStep<BigDecimal> cumeDist()
The cume_dist() over ([analytic clause]) function.







ntile
@Support({AURORA_POSTGRES,CUBRID,DB2_11,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,VERTICA})
public static WindowOverStep<Integer> ntile(int number)
The ntile([number]) over ([analytic clause]) function.







ratioToReport
@Support({AURORA_POSTGRES,CUBRID,DB2_11,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,TERADATA,VERTICA})
public static WindowOverStep<BigDecimal> ratioToReport(Number number)
The ratio_to_report([expression]) over ([analytic clause]) function.







ratioToReport
@Support({AURORA_POSTGRES,CUBRID,DB2_11,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,TERADATA,VERTICA})
public static WindowOverStep<BigDecimal> ratioToReport(Field<? extends Number> field)
The ratio_to_report([expression]) over ([analytic clause]) function.







firstValue
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA})
public static <T> WindowIgnoreNullsStep<T> firstValue(Field<T> field)
The first_value(field) over ([analytic clause]) function.







lastValue
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,SYBASE,TERADATA})
public static <T> WindowIgnoreNullsStep<T> lastValue(Field<T> field)
The last_value(field) over ([analytic clause]) function.







nthValue
@Support({AURORA_POSTGRES,DB2_11,FIREBIRD_3_0,H2,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLITE})
public static <T> WindowFromFirstLastStep<T> nthValue(Field<T> field,
                                                      int nth)
The nth_value(field) over ([analytic clause]) function.







nthValue
@Support({AURORA_POSTGRES,DB2_11,FIREBIRD_3_0,H2,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLITE})
public static <T> WindowFromFirstLastStep<T> nthValue(Field<T> field,
                                                      Field<Integer> nth)
The nth_value(field) over ([analytic clause]) function.







lead
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lead(Field<T> field)
The lead(field) over ([analytic clause]) function.







lead
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lead(Field<T> field,
                                                int offset)
The lead(field, offset) over ([analytic clause]) function.









lead
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lead(Field<T> field,
                                                int offset,
                                                T defaultValue)
The
 lead(field, offset, defaultValue) over ([analytic clause])
 function.







lead
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lead(Field<T> field,
                                                int offset,
                                                Field<T> defaultValue)
The
 lead(field, offset, defaultValue) over ([analytic clause])
 function.







lag
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lag(Field<T> field)
The lag(field) over ([analytic clause]) function.







lag
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lag(Field<T> field,
                                               int offset)
The lag(field, offset) over ([analytic clause]) function.









lag
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lag(Field<T> field,
                                               int offset,
                                               T defaultValue)
The
 lag(field, offset, defaultValue) over ([analytic clause])
 function.







lag
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,INFORMIX,MYSQL_8_0,ORACLE,POSTGRES,REDSHIFT,SQLDATAWAREHOUSE,SQLITE,SQLSERVER2012,TERADATA,VERTICA})
public static <T> WindowIgnoreNullsStep<T> lag(Field<T> field,
                                               int offset,
                                               Field<T> defaultValue)
The
 lag(field, offset, defaultValue) over ([analytic clause])
 function.







param
@Support
public static <T> Param<Object> param()
Create an unnamed parameter with a generic type (Object /
 SQLDataType.OTHER) and no initial value.
 
 Try to avoid this method when using any of these databases, as these
 databases may have trouble inferring the type of the bind value. Use
 typed named parameters instead, using param(Class) or
 param(DataType)
 

  SQLDialect.DB2
  SQLDialect.DERBY
  SQLDialect.H2
  SQLDialect.HSQLDB
  SQLDialect.INGRES
  SQLDialect.SYBASE
 

See Also:
param(String, Object)








param
@Support
public static <T> Param<T> param(Class<T> type)
Create an unnamed parameter with a defined type and no initial value.

See Also:
param(String, Object)








param
@Support
public static <T> Param<T> param(DataType<T> type)
Create an unnamed parameter with a defined type and no initial value.

See Also:
param(String, Object)








param
@Support
public static <T> Param<T> param(Field<T> field)
Create an unnamed parameter with the defined type of another field and no
 initial value.

See Also:
param(String, Object)








param
@Support
public static Param<Object> param(String name)
Create a named parameter with a generic type (Object /
 SQLDataType.OTHER) and no initial value.
 
 Try to avoid this method when using any of these databases, as these
 databases may have trouble inferring the type of the bind value. Use
 typed named parameters instead, using param(String, Class) or
 param(String, DataType)
 

  SQLDialect.DB2
  SQLDialect.DERBY
  SQLDialect.H2
  SQLDialect.HSQLDB
  SQLDialect.INGRES
  SQLDialect.SYBASE
 

See Also:
param(String, Object)








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

See Also:
param(String, Object)








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

See Also:
param(String, Object)








param
@Support
public static <T> Param<T> param(String name,
                                 Field<T> type)
Create a named parameter with a defined type of another field and no
 initial value.

See Also:
param(String, Object)










param
@Support
public static <T> Param<T> param(String name,
                                 T value)
Create a named parameter with an initial value.
 
 Named parameters are useful for several use-cases:
 

 They can be used with Spring's JdbcTemplate, which
 supports named parameters. Use
 DSLContext.renderNamedParams(QueryPart) to render
 parameter names in SQL
 Named parameters can be retrieved using a well-known name from
 Query.getParam(String) and Query.getParams().
 

See Also:
Query.getParam(String), 
Query.getParams(), 
DSLContext.renderNamedParams(QueryPart)










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

See Also:
val(Object)








value
@Support
public static Param<Byte> value(byte value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Byte> value(Byte value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<UByte> value(UByte value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Short> value(short value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Short> value(Short value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<UShort> value(UShort value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Integer> value(int value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Integer> value(Integer value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<UInteger> value(UInteger value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Long> value(long value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Long> value(Long value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<ULong> value(ULong value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Float> value(float value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Float> value(Float value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Double> value(double value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Double> value(Double value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Boolean> value(boolean value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Boolean> value(Boolean value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<BigDecimal> value(BigDecimal value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<BigInteger> value(BigInteger value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<byte[]> value(byte[] value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<String> value(String value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Date> value(Date value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Time> value(Time value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Timestamp> value(Timestamp value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<LocalDate> value(LocalDate value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<LocalTime> value(LocalTime value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<LocalDateTime> value(LocalDateTime value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<OffsetTime> value(OffsetTime value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<OffsetDateTime> value(OffsetDateTime value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<Instant> value(Instant value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static Param<UUID> value(UUID value)
A synonym for val(Object) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object)








value
@Support
public static <T> Param<T> value(Object value,
                                 Class<T> type)
A synonym for val(Object, Class) to be used in Scala and Groovy, where
 val is a reserved keyword.

See Also:
val(Object, Class)








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

See Also:
val(Object, Field)








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

See Also:
val(Object, DataType)










inline
@Support
public static <T> Param<T> inline(T value)
Create a bind value, that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
val(Object)








inline
@Support
public static Param<Byte> inline(byte value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Byte> inline(Byte value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<UByte> inline(UByte value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Short> inline(short value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Short> inline(Short value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<UShort> inline(UShort value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Integer> inline(int value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Integer> inline(Integer value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<UInteger> inline(UInteger value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Long> inline(long value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Long> inline(Long value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<ULong> inline(ULong value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Float> inline(float value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Float> inline(Float value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Double> inline(double value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Double> inline(Double value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Boolean> inline(boolean value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Boolean> inline(Boolean value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<BigDecimal> inline(BigDecimal value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<BigInteger> inline(BigInteger value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<byte[]> inline(byte[] value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<String> inline(String value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Date> inline(Date value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Time> inline(Time value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Timestamp> inline(Timestamp value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<LocalDate> inline(LocalDate value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<LocalTime> inline(LocalTime value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<LocalDateTime> inline(LocalDateTime value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<OffsetTime> inline(OffsetTime value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<OffsetDateTime> inline(OffsetDateTime value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<Instant> inline(Instant value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<UUID> inline(UUID value)
Create a bind value that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String), you can expect value to
 be properly escaped for SQL syntax correctness and SQL injection
 prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
inline(Object), 
val(Object)








inline
@Support
public static Param<String> inline(char character)
Create a bind value, that is always inlined.
 
 This is a convenience method for inline(Object), returning
 Field<String>, rather than
 Field<Character>

See Also:
inline(Object)








inline
@Support
public static Param<String> inline(Character character)
Create a bind value, that is always inlined.
 
 This is a convenience method for inline(Object), returning
 Field<String>, rather than
 Field<Character>

See Also:
inline(Object)








inline
@Support
public static Param<String> inline(CharSequence character)
Create a bind value, that is always inlined.
 
 This is a convenience method for inline(Object), returning
 Field<String>, rather than
 Field<CharSequence>

See Also:
inline(Object)








inline
@Support
public static <T> Param<T> inline(Object value,
                                  Class<T> type)
Create a bind value, that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String, Class), you can expect
 value to be properly escaped for SQL syntax correctness and
 SQL injection prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
val(Object, Class)








inline
@Support
public static <T> Param<T> inline(Object value,
                                  Field<T> field)
Create a bind value, that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String, DataType), you can expect
 value to be properly escaped for SQL syntax correctness and
 SQL injection prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
val(Object, Field)








inline
@Support
public static <T> Param<T> inline(Object value,
                                  DataType<T> type)
Create a bind value, that is always inlined.
 
 The resulting bind value is always inlined, regardless of the
 Settings.getStatementType() property of the rendering factory.
 Unlike with field(String, DataType), you can expect
 value to be properly escaped for SQL syntax correctness and
 SQL injection prevention. For example:
 

 inline("abc'def") renders 'abc''def'
 field("abc'def") renders abc'def
 

See Also:
val(Object, DataType)










val
@Support
public static <T> Param<T> val(T value)
Get a bind value.
 
 jOOQ tries to derive the RDBMS DataType from the provided Java
 type <T>. This may not always be accurate, which can
 lead to problems in some strongly typed RDMBS, especially when value is
 null. These databases are namely:
 

 SQLDialect.DERBY
 SQLDialect.DB2
 SQLDialect.H2
 SQLDialect.HSQLDB
 SQLDialect.INGRES
 SQLDialect.SYBASE
 
 
 If you need more type-safety, please use val(Object, DataType)
 instead, and provide the precise RDMBS-specific data type, that is
 needed.

Type Parameters:
T - The generic value type
Parameters:
value - The constant value
Returns:
A field representing the constant value








val
@Support
public static Param<Byte> val(byte value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Byte> val(Byte value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<UByte> val(UByte value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Short> val(short value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Short> val(Short value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<UShort> val(UShort value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Integer> val(int value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Integer> val(Integer value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<UInteger> val(UInteger value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Long> val(long value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Long> val(Long value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<ULong> val(ULong value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Float> val(float value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Float> val(Float value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Double> val(double value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Double> val(Double value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Boolean> val(boolean value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Boolean> val(Boolean value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<BigDecimal> val(BigDecimal value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<BigInteger> val(BigInteger value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<byte[]> val(byte[] value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<String> val(String value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Date> val(Date value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Time> val(Time value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Timestamp> val(Timestamp value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<LocalDate> val(LocalDate value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<LocalTime> val(LocalTime value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<LocalDateTime> val(LocalDateTime value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<OffsetTime> val(OffsetTime value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<OffsetDateTime> val(OffsetDateTime value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<Instant> val(Instant value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static Param<UUID> val(UUID value)
Get a bind value.

See Also:
val(Object)








val
@Support
public static <T> Param<T> val(Object value,
                               Class<T> type)
Get a bind value with an associated type, taken from a field.

Type Parameters:
T - The generic value type
Parameters:
value - The constant value
type - The data type to enforce upon the value
Returns:
A field representing the constant value
See Also:
val(Object, DataType)








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

Type Parameters:
T - The generic value type
Parameters:
value - The constant value
field - The field whose data type to enforce upon the value
Returns:
A field representing the constant value
See Also:
val(Object, DataType)








val
@Support
public static <T> Param<T> val(Object value,
                               DataType<T> type)
Get a bind value with an associated type.
 
 This will try to bind value as type in a
 PreparedStatement. If value and
 type are not compatible, jOOQ will first try to convert and
 then to cast value to type.

Type Parameters:
T - The generic value type
Parameters:
value - The constant value
type - The data type to enforce upon the value
Returns:
A field representing the constant value








recordType
public static <T1> RecordType<Record> recordType(Field<?>[] fields)
Create a RecordType of an arbitrary degree.







recordType
public static <T1> RecordType<Record> recordType(Collection<? extends Field<?>> fields)
Create a RecordType of an arbitrary degree.







recordType
public static <T1> RecordType<Record1<T1>> recordType(Field<T1> field1)
Create a RecordType of degree 1.







recordType
public static <T1,T2> RecordType<Record2<T1,T2>> recordType(Field<T1> field1,
                                                                        Field<T2> field2)
Create a RecordType of degree 2.







recordType
public static <T1,T2,T3> RecordType<Record3<T1,T2,T3>> recordType(Field<T1> field1,
                                                                                          Field<T2> field2,
                                                                                          Field<T3> field3)
Create a RecordType of degree 3.







recordType
public static <T1,T2,T3,T4> RecordType<Record4<T1,T2,T3,T4>> recordType(Field<T1> field1,
                                                                                                            Field<T2> field2,
                                                                                                            Field<T3> field3,
                                                                                                            Field<T4> field4)
Create a RecordType of degree 4.







recordType
public static <T1,T2,T3,T4,T5> RecordType<Record5<T1,T2,T3,T4,T5>> recordType(Field<T1> field1,
                                                                                                                              Field<T2> field2,
                                                                                                                              Field<T3> field3,
                                                                                                                              Field<T4> field4,
                                                                                                                              Field<T5> field5)
Create a RecordType of degree 5.







recordType
public static <T1,T2,T3,T4,T5,T6> 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 a RecordType of degree 6.







recordType
public static <T1,T2,T3,T4,T5,T6,T7> 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 a RecordType of degree 7.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8> 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 a RecordType of degree 8.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> 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 a RecordType of degree 9.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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 a RecordType of degree 10.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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 a RecordType of degree 11.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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 a RecordType of degree 12.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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 a RecordType of degree 13.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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 a RecordType of degree 14.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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 a RecordType of degree 15.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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 a RecordType of degree 16.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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 a RecordType of degree 17.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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 a RecordType of degree 18.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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 a RecordType of degree 19.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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 a RecordType of degree 20.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> 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 a RecordType of degree 21.







recordType
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> 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 a RecordType of degree 22.









row
@Support
public static <T1> Row1<T1> row(T1 t1)
Create a row value expression of degree 1.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2> Row2<T1,T2> row(T1 t1,
                                                  T2 t2)
Create a row value expression of degree 2.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3> Row3<T1,T2,T3> row(T1 t1,
                                                                    T2 t2,
                                                                    T3 t3)
Create a row value expression of degree 3.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4> Row4<T1,T2,T3,T4> row(T1 t1,
                                                                                      T2 t2,
                                                                                      T3 t3,
                                                                                      T4 t4)
Create a row value expression of degree 4.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5> Row5<T1,T2,T3,T4,T5> row(T1 t1,
                                                                                                        T2 t2,
                                                                                                        T3 t3,
                                                                                                        T4 t4,
                                                                                                        T5 t5)
Create a row value expression of degree 5.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6> Row6<T1,T2,T3,T4,T5,T6> row(T1 t1,
                                                                                                                          T2 t2,
                                                                                                                          T3 t3,
                                                                                                                          T4 t4,
                                                                                                                          T5 t5,
                                                                                                                          T6 t6)
Create a row value expression of degree 6.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7> Row7<T1,T2,T3,T4,T5,T6,T7> row(T1 t1,
                                                                                                                                            T2 t2,
                                                                                                                                            T3 t3,
                                                                                                                                            T4 t4,
                                                                                                                                            T5 t5,
                                                                                                                                            T6 t6,
                                                                                                                                            T7 t7)
Create a row value expression of degree 7.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> Row8<T1,T2,T3,T4,T5,T6,T7,T8> row(T1 t1,
                                                                                                                                                              T2 t2,
                                                                                                                                                              T3 t3,
                                                                                                                                                              T4 t4,
                                                                                                                                                              T5 t5,
                                                                                                                                                              T6 t6,
                                                                                                                                                              T7 t7,
                                                                                                                                                              T8 t8)
Create a row value expression of degree 8.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9> row(T1 t1,
                                                                                                                                                                                T2 t2,
                                                                                                                                                                                T3 t3,
                                                                                                                                                                                T4 t4,
                                                                                                                                                                                T5 t5,
                                                                                                                                                                                T6 t6,
                                                                                                                                                                                T7 t7,
                                                                                                                                                                                T8 t8,
                                                                                                                                                                                T9 t9)
Create a row value expression of degree 9.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> row(T1 t1,
                                                                                                                                                                                                     T2 t2,
                                                                                                                                                                                                     T3 t3,
                                                                                                                                                                                                     T4 t4,
                                                                                                                                                                                                     T5 t5,
                                                                                                                                                                                                     T6 t6,
                                                                                                                                                                                                     T7 t7,
                                                                                                                                                                                                     T8 t8,
                                                                                                                                                                                                     T9 t9,
                                                                                                                                                                                                     T10 t10)
Create a row value expression of degree 10.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> row(T1 t1,
                                                                                                                                                                                                                         T2 t2,
                                                                                                                                                                                                                         T3 t3,
                                                                                                                                                                                                                         T4 t4,
                                                                                                                                                                                                                         T5 t5,
                                                                                                                                                                                                                         T6 t6,
                                                                                                                                                                                                                         T7 t7,
                                                                                                                                                                                                                         T8 t8,
                                                                                                                                                                                                                         T9 t9,
                                                                                                                                                                                                                         T10 t10,
                                                                                                                                                                                                                         T11 t11)
Create a row value expression of degree 11.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> row(T1 t1,
                                                                                                                                                                                                                                             T2 t2,
                                                                                                                                                                                                                                             T3 t3,
                                                                                                                                                                                                                                             T4 t4,
                                                                                                                                                                                                                                             T5 t5,
                                                                                                                                                                                                                                             T6 t6,
                                                                                                                                                                                                                                             T7 t7,
                                                                                                                                                                                                                                             T8 t8,
                                                                                                                                                                                                                                             T9 t9,
                                                                                                                                                                                                                                             T10 t10,
                                                                                                                                                                                                                                             T11 t11,
                                                                                                                                                                                                                                             T12 t12)
Create a row value expression of degree 12.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> row(T1 t1,
                                                                                                                                                                                                                                                                 T2 t2,
                                                                                                                                                                                                                                                                 T3 t3,
                                                                                                                                                                                                                                                                 T4 t4,
                                                                                                                                                                                                                                                                 T5 t5,
                                                                                                                                                                                                                                                                 T6 t6,
                                                                                                                                                                                                                                                                 T7 t7,
                                                                                                                                                                                                                                                                 T8 t8,
                                                                                                                                                                                                                                                                 T9 t9,
                                                                                                                                                                                                                                                                 T10 t10,
                                                                                                                                                                                                                                                                 T11 t11,
                                                                                                                                                                                                                                                                 T12 t12,
                                                                                                                                                                                                                                                                 T13 t13)
Create a row value expression of degree 13.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> row(T1 t1,
                                                                                                                                                                                                                                                                                     T2 t2,
                                                                                                                                                                                                                                                                                     T3 t3,
                                                                                                                                                                                                                                                                                     T4 t4,
                                                                                                                                                                                                                                                                                     T5 t5,
                                                                                                                                                                                                                                                                                     T6 t6,
                                                                                                                                                                                                                                                                                     T7 t7,
                                                                                                                                                                                                                                                                                     T8 t8,
                                                                                                                                                                                                                                                                                     T9 t9,
                                                                                                                                                                                                                                                                                     T10 t10,
                                                                                                                                                                                                                                                                                     T11 t11,
                                                                                                                                                                                                                                                                                     T12 t12,
                                                                                                                                                                                                                                                                                     T13 t13,
                                                                                                                                                                                                                                                                                     T14 t14)
Create a row value expression of degree 14.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> row(T1 t1,
                                                                                                                                                                                                                                                                                                         T2 t2,
                                                                                                                                                                                                                                                                                                         T3 t3,
                                                                                                                                                                                                                                                                                                         T4 t4,
                                                                                                                                                                                                                                                                                                         T5 t5,
                                                                                                                                                                                                                                                                                                         T6 t6,
                                                                                                                                                                                                                                                                                                         T7 t7,
                                                                                                                                                                                                                                                                                                         T8 t8,
                                                                                                                                                                                                                                                                                                         T9 t9,
                                                                                                                                                                                                                                                                                                         T10 t10,
                                                                                                                                                                                                                                                                                                         T11 t11,
                                                                                                                                                                                                                                                                                                         T12 t12,
                                                                                                                                                                                                                                                                                                         T13 t13,
                                                                                                                                                                                                                                                                                                         T14 t14,
                                                                                                                                                                                                                                                                                                         T15 t15)
Create a row value expression of degree 15.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> row(T1 t1,
                                                                                                                                                                                                                                                                                                                             T2 t2,
                                                                                                                                                                                                                                                                                                                             T3 t3,
                                                                                                                                                                                                                                                                                                                             T4 t4,
                                                                                                                                                                                                                                                                                                                             T5 t5,
                                                                                                                                                                                                                                                                                                                             T6 t6,
                                                                                                                                                                                                                                                                                                                             T7 t7,
                                                                                                                                                                                                                                                                                                                             T8 t8,
                                                                                                                                                                                                                                                                                                                             T9 t9,
                                                                                                                                                                                                                                                                                                                             T10 t10,
                                                                                                                                                                                                                                                                                                                             T11 t11,
                                                                                                                                                                                                                                                                                                                             T12 t12,
                                                                                                                                                                                                                                                                                                                             T13 t13,
                                                                                                                                                                                                                                                                                                                             T14 t14,
                                                                                                                                                                                                                                                                                                                             T15 t15,
                                                                                                                                                                                                                                                                                                                             T16 t16)
Create a row value expression of degree 16.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> row(T1 t1,
                                                                                                                                                                                                                                                                                                                                                 T2 t2,
                                                                                                                                                                                                                                                                                                                                                 T3 t3,
                                                                                                                                                                                                                                                                                                                                                 T4 t4,
                                                                                                                                                                                                                                                                                                                                                 T5 t5,
                                                                                                                                                                                                                                                                                                                                                 T6 t6,
                                                                                                                                                                                                                                                                                                                                                 T7 t7,
                                                                                                                                                                                                                                                                                                                                                 T8 t8,
                                                                                                                                                                                                                                                                                                                                                 T9 t9,
                                                                                                                                                                                                                                                                                                                                                 T10 t10,
                                                                                                                                                                                                                                                                                                                                                 T11 t11,
                                                                                                                                                                                                                                                                                                                                                 T12 t12,
                                                                                                                                                                                                                                                                                                                                                 T13 t13,
                                                                                                                                                                                                                                                                                                                                                 T14 t14,
                                                                                                                                                                                                                                                                                                                                                 T15 t15,
                                                                                                                                                                                                                                                                                                                                                 T16 t16,
                                                                                                                                                                                                                                                                                                                                                 T17 t17)
Create a row value expression of degree 17.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> row(T1 t1,
                                                                                                                                                                                                                                                                                                                                                                     T2 t2,
                                                                                                                                                                                                                                                                                                                                                                     T3 t3,
                                                                                                                                                                                                                                                                                                                                                                     T4 t4,
                                                                                                                                                                                                                                                                                                                                                                     T5 t5,
                                                                                                                                                                                                                                                                                                                                                                     T6 t6,
                                                                                                                                                                                                                                                                                                                                                                     T7 t7,
                                                                                                                                                                                                                                                                                                                                                                     T8 t8,
                                                                                                                                                                                                                                                                                                                                                                     T9 t9,
                                                                                                                                                                                                                                                                                                                                                                     T10 t10,
                                                                                                                                                                                                                                                                                                                                                                     T11 t11,
                                                                                                                                                                                                                                                                                                                                                                     T12 t12,
                                                                                                                                                                                                                                                                                                                                                                     T13 t13,
                                                                                                                                                                                                                                                                                                                                                                     T14 t14,
                                                                                                                                                                                                                                                                                                                                                                     T15 t15,
                                                                                                                                                                                                                                                                                                                                                                     T16 t16,
                                                                                                                                                                                                                                                                                                                                                                     T17 t17,
                                                                                                                                                                                                                                                                                                                                                                     T18 t18)
Create a row value expression of degree 18.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> row(T1 t1,
                                                                                                                                                                                                                                                                                                                                                                                         T2 t2,
                                                                                                                                                                                                                                                                                                                                                                                         T3 t3,
                                                                                                                                                                                                                                                                                                                                                                                         T4 t4,
                                                                                                                                                                                                                                                                                                                                                                                         T5 t5,
                                                                                                                                                                                                                                                                                                                                                                                         T6 t6,
                                                                                                                                                                                                                                                                                                                                                                                         T7 t7,
                                                                                                                                                                                                                                                                                                                                                                                         T8 t8,
                                                                                                                                                                                                                                                                                                                                                                                         T9 t9,
                                                                                                                                                                                                                                                                                                                                                                                         T10 t10,
                                                                                                                                                                                                                                                                                                                                                                                         T11 t11,
                                                                                                                                                                                                                                                                                                                                                                                         T12 t12,
                                                                                                                                                                                                                                                                                                                                                                                         T13 t13,
                                                                                                                                                                                                                                                                                                                                                                                         T14 t14,
                                                                                                                                                                                                                                                                                                                                                                                         T15 t15,
                                                                                                                                                                                                                                                                                                                                                                                         T16 t16,
                                                                                                                                                                                                                                                                                                                                                                                         T17 t17,
                                                                                                                                                                                                                                                                                                                                                                                         T18 t18,
                                                                                                                                                                                                                                                                                                                                                                                         T19 t19)
Create a row value expression of degree 19.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> row(T1 t1,
                                                                                                                                                                                                                                                                                                                                                                                                             T2 t2,
                                                                                                                                                                                                                                                                                                                                                                                                             T3 t3,
                                                                                                                                                                                                                                                                                                                                                                                                             T4 t4,
                                                                                                                                                                                                                                                                                                                                                                                                             T5 t5,
                                                                                                                                                                                                                                                                                                                                                                                                             T6 t6,
                                                                                                                                                                                                                                                                                                                                                                                                             T7 t7,
                                                                                                                                                                                                                                                                                                                                                                                                             T8 t8,
                                                                                                                                                                                                                                                                                                                                                                                                             T9 t9,
                                                                                                                                                                                                                                                                                                                                                                                                             T10 t10,
                                                                                                                                                                                                                                                                                                                                                                                                             T11 t11,
                                                                                                                                                                                                                                                                                                                                                                                                             T12 t12,
                                                                                                                                                                                                                                                                                                                                                                                                             T13 t13,
                                                                                                                                                                                                                                                                                                                                                                                                             T14 t14,
                                                                                                                                                                                                                                                                                                                                                                                                             T15 t15,
                                                                                                                                                                                                                                                                                                                                                                                                             T16 t16,
                                                                                                                                                                                                                                                                                                                                                                                                             T17 t17,
                                                                                                                                                                                                                                                                                                                                                                                                             T18 t18,
                                                                                                                                                                                                                                                                                                                                                                                                             T19 t19,
                                                                                                                                                                                                                                                                                                                                                                                                             T20 t20)
Create a row value expression of degree 20.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> row(T1 t1,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T2 t2,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T3 t3,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T4 t4,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T5 t5,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T6 t6,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T7 t7,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T8 t8,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T9 t9,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T10 t10,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T11 t11,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T12 t12,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T13 t13,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T14 t14,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T15 t15,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T16 t16,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T17 t17,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T18 t18,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T19 t19,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T20 t20,
                                                                                                                                                                                                                                                                                                                                                                                                                                 T21 t21)
Create a row value expression of degree 21.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.









row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> row(T1 t1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T2 t2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T3 t3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T4 t4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T5 t5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T6 t6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T7 t7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T8 t8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T9 t9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T10 t10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T11 t11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T12 t12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T13 t13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T14 t14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T15 t15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T16 t16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T17 t17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T18 t18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T19 t19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T20 t20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T21 t21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     T22 t22)
Create a row value expression of degree 22.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static RowN row(Object... values)
Create a row value expression of degree N > 22.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1> Row1<T1> row(Field<T1> t1)
Create a row value expression of degree 1.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2> Row2<T1,T2> row(Field<T1> t1,
                                                  Field<T2> t2)
Create a row value expression of degree 2.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3> Row3<T1,T2,T3> row(Field<T1> t1,
                                                                    Field<T2> t2,
                                                                    Field<T3> t3)
Create a row value expression of degree 3.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4> Row4<T1,T2,T3,T4> row(Field<T1> t1,
                                                                                      Field<T2> t2,
                                                                                      Field<T3> t3,
                                                                                      Field<T4> t4)
Create a row value expression of degree 4.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5> 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 degree 5.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6> 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 degree 6.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7> 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 degree 7.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> 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 degree 8.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> 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 degree 9.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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 degree 10.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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 degree 11.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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 degree 12.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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 degree 13.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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 degree 14.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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 degree 15.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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)
Create a row value expression of degree 16.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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,
                                                                                                                                                                                                                                                                                                                                                 Field<T17> t17)
Create a row value expression of degree 17.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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,
                                                                                                                                                                                                                                                                                                                                                                     Field<T17> t17,
                                                                                                                                                                                                                                                                                                                                                                     Field<T18> t18)
Create a row value expression of degree 18.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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,
                                                                                                                                                                                                                                                                                                                                                                                         Field<T17> t17,
                                                                                                                                                                                                                                                                                                                                                                                         Field<T18> t18,
                                                                                                                                                                                                                                                                                                                                                                                         Field<T19> t19)
Create a row value expression of degree 19.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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,
                                                                                                                                                                                                                                                                                                                                                                                                             Field<T17> t17,
                                                                                                                                                                                                                                                                                                                                                                                                             Field<T18> t18,
                                                                                                                                                                                                                                                                                                                                                                                                             Field<T19> t19,
                                                                                                                                                                                                                                                                                                                                                                                                             Field<T20> t20)
Create a row value expression of degree 20.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> 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,
                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T17> t17,
                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T18> t18,
                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T19> t19,
                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T20> t20,
                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T21> t21)
Create a row value expression of degree 21.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> 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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T17> t17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T18> t18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T19> t19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T20> t20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T21> t21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T22> t22)
Create a row value expression of degree 22.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static RowN row(Field<?>... values)
Create a row value expression of degree N > 22.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







row
@Support
public static RowN row(Collection<?> values)
Create a row value expression of degree N > 22.
 
 Note: Not all databases support row value expressions, but many row value
 expression operations can be emulated on all databases. See relevant row
 value expression method Javadocs for details.







values
@Support
public static Table<Record> values(RowN... rows)
Create a VALUES() expression of arbitrary degree.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2),
       (val2_1, val2_2),
       (val3_1, val3_2)
 AS "v"("c1"  , "c2"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1> Table<Record1<T1>> values(Row1<T1>... rows)
Create a VALUES() expression of degree 1.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1),
       (val2_1),
       (val3_1)
 AS "v"("c1"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1") UNION ALL
 SELECT val1_1 AS "c1") UNION ALL
 SELECT val1_1 AS "c1")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2> Table<Record2<T1,T2>> values(Row2<T1,T2>... rows)
Create a VALUES() expression of degree 2.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2),
       (val2_1, val2_2),
       (val3_1, val3_2)
 AS "v"("c1"  , "c2"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3> Table<Record3<T1,T2,T3>> values(Row3<T1,T2,T3>... rows)
Create a VALUES() expression of degree 3.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3),
       (val2_1, val2_2, val2_3),
       (val3_1, val3_2, val3_3)
 AS "v"("c1"  , "c2"  , "c3"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4> Table<Record4<T1,T2,T3,T4>> values(Row4<T1,T2,T3,T4>... rows)
Create a VALUES() expression of degree 4.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4),
       (val2_1, val2_2, val2_3, val2_4),
       (val3_1, val3_2, val3_3, val3_4)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5> Table<Record5<T1,T2,T3,T4,T5>> values(Row5<T1,T2,T3,T4,T5>... rows)
Create a VALUES() expression of degree 5.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5),
       (val2_1, val2_2, val2_3, val2_4, val2_5),
       (val3_1, val3_2, val3_3, val3_4, val3_5)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6> Table<Record6<T1,T2,T3,T4,T5,T6>> values(Row6<T1,T2,T3,T4,T5,T6>... rows)
Create a VALUES() expression of degree 6.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7> Table<Record7<T1,T2,T3,T4,T5,T6,T7>> values(Row7<T1,T2,T3,T4,T5,T6,T7>... rows)
Create a VALUES() expression of degree 7.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> Table<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> values(Row8<T1,T2,T3,T4,T5,T6,T7,T8>... rows)
Create a VALUES() expression of degree 8.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> Table<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> values(Row9<T1,T2,T3,T4,T5,T6,T7,T8,T9>... rows)
Create a VALUES() expression of degree 9.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Table<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> values(Row10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>... rows)
Create a VALUES() expression of degree 10.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Table<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> values(Row11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>... rows)
Create a VALUES() expression of degree 11.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Table<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> values(Row12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>... rows)
Create a VALUES() expression of degree 12.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Table<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> values(Row13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>... rows)
Create a VALUES() expression of degree 13.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Table<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> values(Row14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>... rows)
Create a VALUES() expression of degree 14.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Table<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> values(Row15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>... rows)
Create a VALUES() expression of degree 15.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Table<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> values(Row16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>... rows)
Create a VALUES() expression of degree 16.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Table<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> values(Row17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>... rows)
Create a VALUES() expression of degree 17.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  , "c17"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Table<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> values(Row18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>... rows)
Create a VALUES() expression of degree 18.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  , "c17"  , "c18"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Table<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> values(Row19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>... rows)
Create a VALUES() expression of degree 19.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  , "c17"  , "c18"  , "c19"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Table<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> values(Row20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>... rows)
Create a VALUES() expression of degree 20.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  , "c17"  , "c18"  , "c19"  , "c20"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Table<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> values(Row21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>... rows)
Create a VALUES() expression of degree 21.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20, val1_21),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20, val2_21),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20, val3_21)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  , "c17"  , "c18"  , "c19"  , "c20"  , "c21"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







values
@SafeVarargs
@Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Table<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> values(Row22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>... rows)
Create a VALUES() expression of degree 22.
 
 The VALUES() constructor is a tool supported by some
 databases to allow for constructing tables from constant values.
 

 If a database doesn't support the VALUES() constructor, it
 can be emulated using SELECT .. UNION ALL ... The following
 expressions are equivalent:
 

 

 -- Using VALUES() constructor
 VALUES(val1_1, val1_2, val1_3, val1_4, val1_5, val1_6, val1_7, val1_8, val1_9, val1_10, val1_11, val1_12, val1_13, val1_14, val1_15, val1_16, val1_17, val1_18, val1_19, val1_20, val1_21, val1_22),
       (val2_1, val2_2, val2_3, val2_4, val2_5, val2_6, val2_7, val2_8, val2_9, val2_10, val2_11, val2_12, val2_13, val2_14, val2_15, val2_16, val2_17, val2_18, val2_19, val2_20, val2_21, val2_22),
       (val3_1, val3_2, val3_3, val3_4, val3_5, val3_6, val3_7, val3_8, val3_9, val3_10, val3_11, val3_12, val3_13, val3_14, val3_15, val3_16, val3_17, val3_18, val3_19, val3_20, val3_21, val3_22)
 AS "v"("c1"  , "c2"  , "c3"  , "c4"  , "c5"  , "c6"  , "c7"  , "c8"  , "c9"  , "c10"  , "c11"  , "c12"  , "c13"  , "c14"  , "c15"  , "c16"  , "c17"  , "c18"  , "c19"  , "c20"  , "c21"  , "c22"  )

 -- Using UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22") UNION ALL
 SELECT val1_1 AS "c1", val1_2 AS "c2", val1_3 AS "c3", val1_4 AS "c4", val1_5 AS "c5", val1_6 AS "c6", val1_7 AS "c7", val1_8 AS "c8", val1_9 AS "c9", val1_10 AS "c10", val1_11 AS "c11", val1_12 AS "c12", val1_13 AS "c13", val1_14 AS "c14", val1_15 AS "c15", val1_16 AS "c16", val1_17 AS "c17", val1_18 AS "c18", val1_19 AS "c19", val1_20 AS "c20", val1_21 AS "c21", val1_22 AS "c22")
 
 
 Use Table.as(String, String...) to rename the resulting table and
 its columns.







nullSafe
protected static <T> Field<T> nullSafe(Field<T> field)
Null-safety of a field.







nullSafe
protected static <T> Field<T> nullSafe(Field<T> field,
                                       DataType<?> type)
Null-safety of a field.







nullSafe
protected static Field<?>[] nullSafe(Field<?>... fields)
Null-safety of a field.







nullSafeDataType
protected static <T> DataType<T> nullSafeDataType(Field<T> field)
Get a default data type if a field is null.







asterisk
@Support
public static Asterisk asterisk()
The asterisk (*) to be used in SELECT clauses.







zero
@Support
public static Param<Integer> zero()
A 0 literal.
 
 This is useful for mathematical functions or for
 EXISTS (SELECT 0 ...) or PARTITION BY 0 clauses
 and similar constructs. The 0 literal will not generate a
 bind variable.

Returns:
A 0 literal as a Field








one
@Support
public static Param<Integer> one()
A 1 literal.
 
 This is useful for mathematical functions or for
 EXISTS (SELECT 1 ...) or PARTITION BY 1 clauses
 and similar constructs. The 1 literal will not generate a
 bind variable.

Returns:
A 1 literal as a Field








two
@Support
public static Param<Integer> two()
A 2 literal.
 
 This is useful for mathematical functions. The 1 literal
 will not generate a bind variable.

Returns:
A 2 literal as a Field








pi
@Support
public static Field<BigDecimal> pi()
The PI literal.
 
 This will be any of the following:
 

 The underlying RDBMS' PI literal or PI() function
 Math.PI
 







e
@Support
public static Field<BigDecimal> e()
The E literal (Euler number).
 
 This will be any of the following:
 

 The underlying RDBMS' E literal or E() function
 Math.E
 







currentUser
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
public static Field<String> currentUser()
Get the current_user() function.







currentSchema
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,TERADATA,VERTICA})
public static Field<String> currentSchema()
Get the current_schema() function.









widthBucket
@Support
public static <T extends Number> Field<T> widthBucket(Field<T> field,
                                                      T low,
                                                      T high,
                                                      int buckets)







widthBucket
@Support
public static <T extends Number> Field<T> widthBucket(Field<T> field,
                                                      Field<T> low,
                                                      Field<T> high,
                                                      Field<Integer> buckets)







getDataType
@Deprecated
@Support
public static <T> DataType<T> getDataType(Class<T> type)
Deprecated.
- 3.11.0 - [#7483] - The (indirect) use of the internal
             static data type registry is not recommended.

Get the default data type for the DSLContext's underlying
 SQLDialect and a given Java type.

Type Parameters:
T - The generic type
Parameters:
type - The Java type
Returns:
The DSL's underlying default data type.

Function call	yields...
trunc(125.815)	125
trunc(125.815, 0)	125
trunc(125.815, 1)	125.8
trunc(125.815, 2)	125.81
trunc(125.815, -1)	120
trunc(125.815, -2)	100

`SQLDialect`	Java	SQL
`SQLDialect.H2`	array(1, 2)	(1, 2)
`SQLDialect.HSQLDB`, `SQLDialect.POSTGRES`	array(1, 2)	array[1, 2]

Class DSL

DSL and static imports

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DSL

Method Detail

using

using

using

using

using

using

using

using

using

using

using

using

using

using

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

with

withRecursive

withRecursive

withRecursive

withRecursive

withRecursive

withRecursive

withRecursive

withRecursive