DSL (jOOQ 3.4.5 API)

java.lang.Object
- org.jooq.impl.DSL

Direct Known Subclasses:

AccessDSL, ASEDSL, CUBRIDDSL, DB2DSL, DerbyDSL, FirebirdDSL, H2DSL, HSQLDBDSL, IngresDSL, MariaDBDSL, MySQLDSL, OracleDSL, PostgresDSL, SQLiteDSL, SQLServerDSL, SybaseDSL
```
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 instanciate 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 and Description

protected DSL()
No instances.

Constructors
Modifier	Constructor and Description
`protected`	`DSL()` No instances.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and 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(Field<? extends Number> field)` Get the arc cosine(field) function.
`static Field<BigDecimal>`	`acos(Number value)` 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 <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 <T extends Number> AlterSequenceRestartStep<T>`	`alterSequence(Sequence<T> sequence)` Create a new DSL `ALTER SEQUENCE` statement.
`static AlterSequenceRestartStep<BigInteger>`	`alterSequence(String sequence)` Create a new DSL `ALTER SEQUENCE` statement.
`static AlterTableStep`	`alterTable(String table)` Create a new DSL `ALTER TABLE` statement.
`static AlterTableStep`	`alterTable(Table<?> table)` Create a new DSL `ALTER TABLE` statement.
`static <T> QuantifiedSelect<Record1<T>>`	`any(Field<T[]> array)` 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 Field<Integer>`	`ascii(Field<String> field)` Get the ascii(field) function.
`static Field<Integer>`	`ascii(String field)` Get the ascii(field) function.
`static Field<BigDecimal>`	`asin(Field<? extends Number> field)` Get the arc sine(field) function.
`static Field<BigDecimal>`	`asin(Number value)` Get the arc sine(field) function.
`static Field<BigDecimal>`	`atan(Field<? extends Number> field)` Get the arc tangent(field) function.
`static Field<BigDecimal>`	`atan(Number value)` Get the arc tangent(field) function.
`static Field<BigDecimal>`	`atan2(Field<? extends 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(Number x, Field<? extends Number> y)` Get the atan2(field, y) function.
`static Field<BigDecimal>`	`atan2(Number x, 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 <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(Field<? extends Number> field)` The MySQL `BIT_COUNT(field)` function, counting the number of bits that are set in this number.
`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>`	`bitLength(Field<String> field)` Get the bit_length(field) function.
`static Field<Integer>`	`bitLength(String value)` 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 <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>`	`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>`	`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 <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>`	`charLength(Field<String> field)` Get the char_length(field) function.
`static Field<Integer>`	`charLength(String value)` Get the char_length(field) function.
`static <T> Field<T>`	`coalesce(Field<T> field, Field<?>... fields)` Gets the Oracle-style `COALESCE(field1, field2, ... , field n)` function.
`static <T> Field<T>`	`coalesce(T value, T... values)` Gets the Oracle-style `COALESCE(value1, value2, ... , value n)` function.
`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 Field<String>`	`concat(Field<?>... fields)` Get the concat(field[, field, ...]) function.
`static Field<String>`	`concat(String... values)` Get the concat(value[, value, ...]) function.
`static Condition`	`condition(Boolean value)` Create a condition from a boolean field.
`static Condition`	`condition(Field<Boolean> field)` 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 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 Field<BigDecimal>`	`cos(Field<? extends Number> field)` Get the cosine(field) function.
`static Field<BigDecimal>`	`cos(Number value)` Get the cosine(field) function.
`static Field<BigDecimal>`	`cosh(Field<? extends Number> field)` Get the hyperbolic cosine function: cosh(field).
`static Field<BigDecimal>`	`cosh(Number value)` Get the hyperbolic cosine function: cosh(field).
`static Field<BigDecimal>`	`cot(Field<? extends Number> field)` Get the cotangent(field) function.
`static Field<BigDecimal>`	`cot(Number value)` Get the cotangent(field) function.
`static Field<BigDecimal>`	`coth(Field<? extends Number> field)` Get the hyperbolic cotangent function: coth(field).
`static Field<BigDecimal>`	`coth(Number value)` 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>`	`countDistinct(Field<?>... fields)` Get the count(distinct field1, field2) function.
`static AggregateFunction<Integer>`	`countDistinct(Field<?> field)` Get the count(distinct field) function.
`static GroupField`	`cube(Field<?>... fields)` Create a CUBE(field1, field2, .., fieldn) grouping field.
`static WindowOverStep<BigDecimal>`	`cumeDist()` The `cume_dist() over ([analytic clause])` function.
`static OrderedAggregateFunction<BigDecimal>`	`cumeDist(Field<?>... fields)` The `cume_dist(expr) within group (order by [order clause])` ordered aggregate function.
`static Field<Date>`	`currentDate()` Get the current_date() function.
`static Field<Time>`	`currentTime()` Get the current_time() function.
`static Field<Timestamp>`	`currentTimestamp()` Get the current_timestamp() function.
`static Field<String>`	`currentUser()` Get the current_user() function.
`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>`	`date(String value)` Convert a string value to a `DATE`.
`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(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(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<Date>`	`dateAdd(Field<Date> date, 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<Integer>`	`day(Date value)` Get the day part of a date.
`static Field<Integer>`	`day(Field<? extends Date> field)` Get the day part of a date.
`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]... [, default])` function.
`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.
`static <Z,T> Field<Z>`	`decode(T value, T search, Z result)` Gets the Oracle-style `DECODE(expression, search, result[, search , result]... [, default])` function.
`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.
`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 Field<BigDecimal>`	`deg(Field<? extends Number> field)` Calculate degrees from radians from this field.
`static Field<BigDecimal>`	`deg(Number value)` Calculate degrees from radians from this field.
`static <R extends Record> DeleteWhereStep<R>`	`delete(Table<R> table)` Create a new DSL delete statement.
`static WindowOverStep<Integer>`	`denseRank()` The `dense_rank() over ([analytic clause])` function.
`static OrderedAggregateFunction<Integer>`	`denseRank(Field<?>... fields)` The `dense_rank(expr) within group (order by [order clause])` ordered aggregate function.
`static DropTableStep`	`dropTable(String table)` Create a new DSL `DROP TABLE` statement.
`static DropTableStep`	`dropTable(Table<?> table)` Create a new DSL `DROP TABLE` 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<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 String`	`escape(String value, char escape)` Convenience method for `replace(Field, String, String)` to escape data for use with `Field.like(Field, char)`.
`static Condition`	`exists(Select<?> query)` Create an exists condition.
`static Field<BigDecimal>`	`exp(Field<? extends Number> field)` Get the exp(field) function, taking this field as the power of e.
`static Field<BigDecimal>`	`exp(Number value)` Get the exp(field) function, taking this field as the power of e.
`static Field<Integer>`	`extract(Date value, DatePart datePart)` Get the extract(field, datePart) function.
`static Field<Integer>`	`extract(Field<? extends Date> field, DatePart datePart)` Get the extract(field, datePart) function.
`static Condition`	`falseCondition()` Return a `Condition` that will always evaluate to false.
`static Field<Boolean>`	`field(Condition condition)` Transform a condition into a boolean field.
`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 <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)` A custom SQL clause that can render arbitrary SQL elements.
`static Field<Object>`	`field(String sql, Object... bindings)` Create a "plain SQL" field.
`static Field<Object>`	`field(String sql, QueryPart... parts)` A custom SQL clause that can render arbitrary SQL elements.
`static <T> Field<T>`	`fieldByName(Class<T> type, String... qualifiedName)` Create a qualified field, given its (qualified) field name.
`static <T> Field<T>`	`fieldByName(DataType<T> type, String... qualifiedName)` Create a qualified field, given its (qualified) field name.
`static Field<Object>`	`fieldByName(String... qualifiedName)` Create a qualified field, given its (qualified) field name.
`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> 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 <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 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, int to)` A table function generating a series of values from `from` to `to` (inclusive).
`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, int to)` A table function generating a series of values from `from` to `to` (inclusive).
`static <T> DataType<T>`	`getDataType(Class<T> type)` Get the default data type for the `DSLContext`'s underlying `SQLDialect` and a given Java type.
`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)` Get the aggregated concatenation for a field.
`static GroupConcatOrderByStep`	`groupConcatDistinct(Field<?> field)` Get the aggregated concatenation for a field.
`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 Field<Integer>`	`hour(Date value)` Get the hour part of a date.
`static Field<Integer>`	`hour(Field<? extends Date> field)` Get the hour part of a date.
`static Param<String>`	`inline(char character)` 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 <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 <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 <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 Keyword`	`keyword(String keyword)` Create a SQL keyword.
`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(Field<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(String field, Field<? extends Number> length)` Get the left outermost characters from a string.
`static Field<String>`	`left(String field, int length)` Get the left outermost characters from a string.
`static Field<Integer>`	`length(Field<String> field)` Get the length of a `VARCHAR` type.
`static Field<Integer>`	`length(String value)` 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 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(Field<? extends Number> field)` Get the ln(field) function, taking the natural logarithm of this field.
`static Field<BigDecimal>`	`ln(Number value)` Get the ln(field) function, taking the natural logarithm of this field.
`static Field<BigDecimal>`	`log(Field<? extends Number> field, int base)` Get the log(field, base) function.
`static Field<BigDecimal>`	`log(Number value, int base)` Get the log(field, base) function.
`static Field<String>`	`lower(Field<String> field)` Get the lower(field) function.
`static Field<String>`	`lower(String value)` Get the lower(field) 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>`	`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>`	`ltrim(Field<String> field)` Get the ltrim(field) function.
`static Field<String>`	`ltrim(String value)` Get the ltrim(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(Field<String> string)` Get the MySQL-specific `MD5()` function.
`static Field<String>`	`md5(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 merge statement (H2-specific syntax).
`static <R extends Record,T1,T2> MergeKeyStep2<R,T1,T2>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2)` Create a new DSL merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`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 merge statement (H2-specific syntax).
`static Field<String>`	`mid(Field<String> field, Field<? extends Number> startingPosition, Field<? extends Number> length)` Get the mid(field, startingPosition, length) function.
`static Field<String>`	`mid(Field<String> field, int startingPosition, int length)` Get the mid(field, startingPosition, length) function.
`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 Field<Integer>`	`minute(Date value)` Get the minute part of a date.
`static Field<Integer>`	`minute(Field<? extends Date> field)` Get the minute part of a date.
`static Field<Integer>`	`month(Date value)` Get the month part of a date.
`static Field<Integer>`	`month(Field<? extends Date> field)` Get the month part of a date.
`static Name`	`name(String... qualifiedName)` Create a new SQL identifier using a qualified name.
`static Field<Boolean>`	`not(Boolean value)` Invert a boolean value.
`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 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> 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(Field<String> field)` Get the octet_length(field) function.
`static Field<Integer>`	`octetLength(String value)` Get the octet_length(field) function.
`static Field<Integer>`	`one()` A `1` literal.
`static WindowSpecificationRowsStep`	`orderBy(Collection<? extends SortField<?>> fields)` Create a `WindowSpecification` with an `ORDER BY` clause.
`static WindowSpecificationOrderByStep`	`orderBy(Field<?>... fields)` Create a `WindowSpecification` with an `ORDER BY` clause.
`static WindowSpecificationRowsStep`	`orderBy(SortField<?>... fields)` Create a `WindowSpecification` with an `ORDER BY` clause.
`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, T value)` Create a named parameter with an 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 WindowOverStep<BigDecimal>`	`percentRank()` The `precent_rank() over ([analytic clause])` function.
`static OrderedAggregateFunction<Integer>`	`percentRank(Field<?>... fields)` The `percent_rank(expr) within group (order by [order clause])` ordered aggregate function.
`static Field<BigDecimal>`	`pi()` The `PI` literal.
`static Field<Integer>`	`position(Field<String> in, Field<String> search)` Get the position(in, search) function.
`static Field<Integer>`	`position(Field<String> in, String search)` Get the position(in, search) function.
`static Field<Integer>`	`position(String in, Field<String> search)` Get the position(in, search) function.
`static Field<Integer>`	`position(String in, String search)` Get the position(in, search) function.
`static Field<BigDecimal>`	`power(Field<? extends Number> field, 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(Number value, Field<? extends Number> exponent)` Get the power(field, exponent) function.
`static Field<BigDecimal>`	`power(Number value, Number exponent)` Get the power(field, exponent) function.
`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 QueryPart`	`queryPart(String sql)` A custom SQL clause that can render arbitrary expressions.
`static QueryPart`	`queryPart(String sql, Object... bindings)` A custom SQL clause that can render arbitrary expressions.
`static QueryPart`	`queryPart(String sql, QueryPart... parts)` A custom SQL clause that can render arbitrary expressions.
`static Field<BigDecimal>`	`rad(Field<? extends Number> field)` Calculate radians from degrees from this field.
`static Field<BigDecimal>`	`rad(Number value)` Calculate radians from degrees from this field.
`static Field<BigDecimal>`	`rand()` Get the rand() function.
`static WindowOverStep<Integer>`	`rank()` The `rank() over ([analytic clause])` function.
`static OrderedAggregateFunction<Integer>`	`rank(Field<?>... fields)` The `rank(expr) within group (order by [order clause])` ordered aggregate function.
`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(Field<String> field, Field<? extends Number> count)` Get the repeat(field, count) function.
`static Field<String>`	`repeat(Field<String> field, int count)` Get the repeat(count) function.
`static Field<String>`	`repeat(String field, Field<? extends Number> count)` Get the repeat(field, count) function.
`static Field<String>`	`repeat(String field, int count)` Get the repeat(field, count) 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 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>`	`reverse(Field<String> field)` Get the `reverse(field)` function.
`static Field<String>`	`reverse(String value)` Get the `reverse(field)` function.
`static Field<String>`	`right(Field<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(String field, Field<? extends Number> length)` Get the right outermost characters from a string.
`static Field<String>`	`right(String field, int length)` Get the right outermost characters from a string.
`static GroupField`	`rollup(Field<?>... 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(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 RowN`	`row(Object... values)` Create a row value expression of degree `N > 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 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 WindowSpecificationFinalStep`	`rowsCurrentRow()` Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationFinalStep`	`rowsFollowing(int number)` Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationFinalStep`	`rowsPreceding(int number)` Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationFinalStep`	`rowsUnboundedFollowing()` Create a `WindowSpecification` with a `ROWS` clause.
`static WindowSpecificationFinalStep`	`rowsUnboundedPreceding()` Create a `WindowSpecification` with a `ROWS` clause.
`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>`	`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>`	`rtrim(Field<String> field)` Get the rtrim(field) function.
`static Field<String>`	`rtrim(String value)` Get the rtrim(field) function.
`static Schema`	`schemaByName(String name)` Create a qualified schema, given its schema name.
`static Field<Integer>`	`second(Date value)` Get the second part of a date.
`static Field<Integer>`	`second(Field<? extends Date> field)` Get the second part of a date.
`static SelectSelectStep<Record>`	`select(Collection<? extends Field<?>> fields)` Create a new DSL subselect statement.
`static SelectSelectStep<Record>`	`select(Field<?>... fields)` Create a new DSL subselect statement.
`static <T1> SelectSelectStep<Record1<T1>>`	`select(Field<T1> field1)` Create a new DSL subselect statement.
`static <T1,T2> SelectSelectStep<Record2<T1,T2>>`	`select(Field<T1> field1, Field<T2> field2)` Create a new DSL subselect statement.
`static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>>`	`select(Field<T1> field1, Field<T2> field2, Field<T3> field3)` Create a new DSL subselect statement.
`static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>>`	`select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)` Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>>`	`select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)` Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>>`	`select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<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(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 subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`select(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 subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`select(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 subselect statement.
`static SelectSelectStep<Record1<Integer>>`	`selectCount()` Create a new DSL subselect statement for `COUNT(*)`.
`static SelectSelectStep<Record>`	`selectDistinct(Collection<? extends Field<?>> fields)` Create a new DSL subselect statement.
`static SelectSelectStep<Record>`	`selectDistinct(Field<?>... fields)` Create a new DSL subselect statement.
`static <T1> SelectSelectStep<Record1<T1>>`	`selectDistinct(Field<T1> field1)` Create a new DSL subselect statement.
`static <T1,T2> SelectSelectStep<Record2<T1,T2>>`	`selectDistinct(Field<T1> field1, Field<T2> field2)` Create a new DSL subselect statement.
`static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>>`	`selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3)` Create a new DSL subselect statement.
`static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>>`	`selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)` Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>>`	`selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)` Create a new DSL subselect statement.
`static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>>`	`selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<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(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 subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`selectDistinct(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 subselect statement.
`static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`selectDistinct(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 subselect statement.
`static <R extends Record> SelectWhereStep<R>`	`selectFrom(Table<R> table)` Create a new DSL select statement.
`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)` Create a "plain SQL" sequence.
`static <T extends Number> Sequence<T>`	`sequence(String sql, Class<T> type)` Create a "plain SQL" sequence.
`static <T extends Number> Sequence<T>`	`sequence(String sql, DataType<T> type)` Create a "plain SQL" sequence.
`static <T extends Number> Sequence<T>`	`sequenceByName(Class<T> type, String... qualifiedName)` Create a qualified sequence, given its sequence name.
`static <T extends Number> Sequence<T>`	`sequenceByName(DataType<T> type, String... qualifiedName)` Create a qualified sequence, given its sequence name.
`static Sequence<BigInteger>`	`sequenceByName(String... qualifiedName)` Create a qualified sequence, given its sequence name.
`static <T extends Number> Field<T>`	`shl(Field<T> field1, Field<T> field2)` The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shl(Field<T> value1, T value2)` The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shl(T value1, Field<T> value2)` The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shl(T value1, T value2)` The bitwise left shift operator.
`static <T extends Number> Field<T>`	`shr(Field<T> field1, Field<T> field2)` The bitwise right shift operator.
`static <T extends Number> Field<T>`	`shr(Field<T> value1, T value2)` The bitwise right shift operator.
`static <T extends Number> Field<T>`	`shr(T value1, Field<T> value2)` The bitwise right shift operator.
`static <T extends Number> Field<T>`	`shr(T value1, T value2)` The bitwise right shift operator.
`static Field<Integer>`	`sign(Field<? extends Number> field)` Get the sign of a numeric field: sign(field).
`static Field<Integer>`	`sign(Number value)` Get the sign of a numeric field: sign(field).
`static Field<BigDecimal>`	`sin(Field<? extends Number> field)` Get the sine(field) function.
`static Field<BigDecimal>`	`sin(Number value)` Get the sine(field) function.
`static Field<BigDecimal>`	`sinh(Field<? extends Number> field)` Get the hyperbolic sine function: sinh(field).
`static Field<BigDecimal>`	`sinh(Number value)` Get the hyperbolic sine function: sinh(field).
`static Field<String>`	`space(Field<Integer> value)` Get the SQL Server specific `SPACE()` function.
`static Field<String>`	`space(int value)` Get the SQL Server specific `SPACE()` function.
`static Field<BigDecimal>`	`sqrt(Field<? extends Number> field)` Get the sqrt(field) function.
`static Field<BigDecimal>`	`sqrt(Number value)` Get the sqrt(field) function.
`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, 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 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 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(ArrayRecord<?> array)` A synonym for `unnest(ArrayRecord)`.
`static Table<?>`	`table(Field<?> cursor)` A synonym for `unnest(Field)`.
`static Table<?>`	`table(List<?> list)` A synonym for `unnest(List)`.
`static Table<?>`	`table(Object[] array)` A synonym for `unnest(Object[])`.
`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(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<Record>`	`tableByName(String... qualifiedName)` Create a qualified table, given its table name.
`static Field<BigDecimal>`	`tan(Field<? extends Number> field)` Get the tangent(field) function.
`static Field<BigDecimal>`	`tan(Number value)` Get the tangent(field) function.
`static Field<BigDecimal>`	`tanh(Field<? extends Number> field)` Get the hyperbolic tangent function: tanh(field).
`static Field<BigDecimal>`	`tanh(Number value)` Get the hyperbolic tangent function: tanh(field).
`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<Time>`	`time(String value)` Convert a string value to a `TIME`.
`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>`	`timestamp(String value)` Convert a string value to a `TIMESTAMP`.
`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<Timestamp>`	`timestampAdd(Field<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(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<DayToSecond>`	`timestampDiff(Field<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(Timestamp timestamp1, Field<Timestamp> timestamp2)` Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<DayToSecond>`	`timestampDiff(Timestamp timestamp1, Timestamp timestamp2)` Get the timestamp difference as a `INTERVAL DAY TO SECOND` type.
`static Field<String>`	`trim(Field<String> field)` Get the trim(field) function.
`static Field<String>`	`trim(String value)` Get the trim(field) function.
`static Condition`	`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 <T extends Date> Field<T>`	`trunc(Field<T> date)` Truncate a date or a timestamp to the beginning of the day.
`static <T extends Date> 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(Field<T> number, int 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, Field<Integer> decimals)` Truncate a number to a given number of decimals.
`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 <T extends Number> Field<T>`	`trunc(T number, int decimals)` Truncate a number to a given number of decimals.
`static <R extends Record> TruncateIdentityStep<R>`	`truncate(Table<R> table)` Create a new DSL truncate statement.
`static Field<Integer>`	`two()` A `2` literal.
`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 Table<?>`	`unnest(List<?> list)` Create a table from a list of values.
`static Table<?>`	`unnest(Object[] array)` Create a table from an array of values.
`static <R extends Record> UpdateSetFirstStep<R>`	`update(Table<R> table)` Create a new DSL update statement.
`static Field<String>`	`upper(Field<String> field)` Get the upper(field) function.
`static Field<String>`	`upper(String value)` Get the upper(field) function.
`static DSLContext`	`using(Configuration configuration)` Create an executor from a custom configuration.
`static DSLContext`	`using(Connection connection)` Create an executor with a connection configured.
`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(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(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 <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 <T> Param<T>`	`val(T value)` Get a bind value.
`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 <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 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 WithStep`	`with(CommonTableExpression<?>... tables)` Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static WithAsStep`	`with(String alias)` 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 WithStep`	`withRecursive(CommonTableExpression<?>... tables)` 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 WithAsStep`	`withRecursive(String alias, String... fieldAliases)` Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`static Field<Integer>`	`year(Date value)` Get the year part of a date.
`static Field<Integer>`	`year(Field<? extends Date> field)` Get the year part of a date.
`static Field<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(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(value={DB2,FIREBIRD,HSQLDB,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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(value={DB2,FIREBIRD,HSQLDB,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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(value={DB2,FIREBIRD,HSQLDB,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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(value={DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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(value={DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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(value={DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,SYBASE})
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.
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] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
 
```

select
```
@Support
public static SelectSelectStep<Record> select(Collection<? extends Field<?>> 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);
 
```
See Also:

DSLContext.select(Collection)

select
```
@Support
public static SelectSelectStep<Record> select(Field<?>... 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);
 
```
See Also:

DSLContext.select(Field...)

select
```
@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1> SelectSelectStep<Record1<T1>> select(Field<T1> field1)
```
Create a new DSL subselect statement.
This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2> SelectSelectStep<Record2<T1,T2>> select(Field<T1> field1,
                                                                                                                                         Field<T2> field2)

Create a new DSL subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> select(Field<T1> field1,
                                                                                                                                               Field<T2> field2,
                                                                                                                                               Field<T3> field3)

Create a new DSL subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>> select(Field<T1> field1,
                                                                                                                                                     Field<T2> field2,
                                                                                                                                                     Field<T3> field3,
                                                                                                                                                     Field<T4> field4)

Create a new DSL subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>> select(Field<T1> field1,
                                                                                                                                                           Field<T2> field2,
                                                                                                                                                           Field<T3> field3,
                                                                                                                                                           Field<T4> field4,
                                                                                                                                                           Field<T5> field5)

Create a new DSL subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> select(Field<T1> field1,
                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                 Field<T6> field6)

Create a new DSL subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> select(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> select(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> select(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

select

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as select(Field...), 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(Field...), select(Field...)

selectDistinct
```
@Support
public static SelectSelectStep<Record> selectDistinct(Collection<? extends Field<?>> 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);
 
```
See Also:

DSLContext.selectDistinct(Collection)

selectDistinct
```
@Support
public static SelectSelectStep<Record> selectDistinct(Field<?>... 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);
 
```
See Also:

DSLContext.selectDistinct(Field...)

selectDistinct
```
@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1> SelectSelectStep<Record1<T1>> selectDistinct(Field<T1> field1)
```
Create a new DSL subselect statement.
This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2> SelectSelectStep<Record2<T1,T2>> selectDistinct(Field<T1> field1,
                                                                                                                                                 Field<T2> field2)

Create a new DSL subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> selectDistinct(Field<T1> field1,
                                                                                                                                                       Field<T2> field2,
                                                                                                                                                       Field<T3> field3)

Create a new DSL subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>> selectDistinct(Field<T1> field1,
                                                                                                                                                             Field<T2> field2,
                                                                                                                                                             Field<T3> field3,
                                                                                                                                                             Field<T4> field4)

Create a new DSL subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>> selectDistinct(Field<T1> field1,
                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                   Field<T5> field5)

Create a new DSL subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> selectDistinct(Field<T1> field1,
                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                         Field<T6> field6)

Create a new DSL subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> selectDistinct(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> selectDistinct(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @Support
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> selectDistinct(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

selectDistinct

@Generated(value="This method was generated using jOOQ-tools")
 @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(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 subselect statement.

This is the same as selectDistinct(Field...), 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(Field...), selectDistinct(Field...)

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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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

@Generated(value="This method was generated using jOOQ-tools")
 @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,

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

with

with

with

withRecursive

withRecursive

withRecursive

selectFrom

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

select

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectDistinct

selectZero

selectOne

selectCount

insertInto

insertInto

insertInto