All Superinterfaces:

AutoCloseable, Scope

All Known Implementing Classes:

DefaultDSLContext
```
public interface DSLContext
extends Scope, AutoCloseable
```
A contextual DSL providing "attached" implementations to the org.jooq interfaces.
Apart from the DSL, this contextual DSL is the main entry point for client code, to access jOOQ classes and functionality that are related to Query execution. Unlike objects created through the DSL type, objects created from a DSLContext will be "attached" to the DSLContext's Scope.configuration(), such that they can be executed immediately in a fluent style. An example is given here:
```
 DSLContext create = DSL.using(connection, dialect);

 // Immediately fetch results after constructing a query
 create.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)).fetch();

 // The above is equivalent to this "non-fluent" style
 create.fetch(DSL.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)));
 
```
The DSL provides convenient constructors to create a Configuration, which will be shared among all Query objects thus created. Optionally, you can pass a reusable Configuration to the DSL.using(Configuration) constructor. Please consider thread-safety concerns documented in Configuration, should you want to reuse the same Configuration instance in various threads and / or transactions.
Author:

Lukas Eder

See Also:

DSL, Configuration

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method	Description
`AlterIndexOnStep`	`alterIndex(String index)`	Create a new DSL `ALTER INDEX` statement.
`AlterIndexOnStep`	`alterIndex(Index index)`	Create a new DSL `ALTER INDEX` statement.
`AlterIndexOnStep`	`alterIndex(Name index)`	Create a new DSL `ALTER INDEX` statement.
`AlterIndexStep`	`alterIndexIfExists(String index)`	Create a new DSL `ALTER INDEX` statement.
`AlterIndexStep`	`alterIndexIfExists(Index index)`	Create a new DSL `ALTER INDEX` statement.
`AlterIndexStep`	`alterIndexIfExists(Name index)`	Create a new DSL `ALTER INDEX` statement.
`AlterSchemaStep`	`alterSchema(String schema)`	Create a new DSL `ALTER SCHEMA` statement.
`AlterSchemaStep`	`alterSchema(Name schema)`	Create a new DSL `ALTER SCHEMA` statement.
`AlterSchemaStep`	`alterSchema(Schema schema)`	Create a new DSL `ALTER SCHEMA` statement.
`AlterSchemaStep`	`alterSchemaIfExists(String schema)`	Create a new DSL `ALTER SCHEMA` statement.
`AlterSchemaStep`	`alterSchemaIfExists(Name schema)`	Create a new DSL `ALTER SCHEMA` statement.
`AlterSchemaStep`	`alterSchemaIfExists(Schema schema)`	Create a new DSL `ALTER SCHEMA` statement.
`AlterSequenceStep<BigInteger>`	`alterSequence(String sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterSequenceStep<BigInteger>`	`alterSequence(Name sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`<T extends Number> AlterSequenceStep<T>`	`alterSequence(Sequence<T> sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterSequenceStep<BigInteger>`	`alterSequenceIfExists(String sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterSequenceStep<BigInteger>`	`alterSequenceIfExists(Name sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`<T extends Number> AlterSequenceStep<T>`	`alterSequenceIfExists(Sequence<T> sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterTableStep`	`alterTable(String table)`	Create a new DSL `ALTER TABLE` statement.
`AlterTableStep`	`alterTable(Name table)`	Create a new DSL `ALTER TABLE` statement.
`AlterTableStep`	`alterTable(Table<?> table)`	Create a new DSL `ALTER TABLE` statement.
`AlterTableStep`	`alterTableIfExists(String table)`	Create a new DSL `ALTER TABLE` statement.
`AlterTableStep`	`alterTableIfExists(Name table)`	Create a new DSL `ALTER TABLE` statement.
`AlterTableStep`	`alterTableIfExists(Table<?> table)`	Create a new DSL `ALTER TABLE` statement.
`AlterViewStep`	`alterView(String view)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterView(Name view)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterView(Table<?> view)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterViewIfExists(String view)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterViewIfExists(Name view)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterViewIfExists(Table<?> view)`	Create a new DSL `ALTER VIEW` statement.
`void`	`attach(Collection<? extends Attachable> attachables)`	Attach this `DSLContext`'s underlying `Scope.configuration()` to some attachables.
`void`	`attach(Attachable... attachables)`	Attach this `DSLContext`'s underlying `Scope.configuration()` to some attachables.
`BatchBindStep`	`batch(String sql)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batch(String... queries)`	Create a batch statement to execute a set of queries in batch mode (without bind values).
`Batch`	`batch(String sql, Object[]... bindings)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batch(Collection<? extends Query> queries)`	Create a batch statement to execute a set of queries in batch mode (without bind values).
`Batch`	`batch(Queries queries)`	Create a batch statement to execute a set of queries in batch mode (without bind values).
`BatchBindStep`	`batch(Query query)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batch(Query... queries)`	Create a batch statement to execute a set of queries in batch mode (without bind values).
`Batch`	`batch(Query query, Object[]... bindings)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batchDelete(Collection<? extends UpdatableRecord<?>> records)`	Create a batch statement to execute a set of `DELETE` queries in batch mode (with bind values) according to `UpdatableRecord.delete()` sematics.
`Batch`	`batchDelete(UpdatableRecord<?>... records)`	Create a batch statement to execute a set of `DELETE` queries in batch mode (with bind values) according to `UpdatableRecord.delete()` sematics.
`Batch`	`batchInsert(Collection<? extends TableRecord<?>> records)`	Create a batch statement to execute a set of `INSERT` queries in batch mode (with bind values) according to `TableRecord.insert()` semantics.
`Batch`	`batchInsert(TableRecord<?>... records)`	Create a batch statement to execute a set of `INSERT` queries in batch mode (with bind values) according to `TableRecord.insert()` semantics.
`Batch`	`batchStore(Collection<? extends UpdatableRecord<?>> records)`	Create a batch statement to execute a set of `INSERT` and `UPDATE` queries in batch mode (with bind values) according to `UpdatableRecord.store()` semantics.
`Batch`	`batchStore(UpdatableRecord<?>... records)`	Create a batch statement to execute a set of `INSERT` and `UPDATE` queries in batch mode (with bind values) according to `UpdatableRecord.store()` semantics.
`Batch`	`batchUpdate(Collection<? extends UpdatableRecord<?>> records)`	Create a batch statement to execute a set of `UPDATE` queries in batch mode (with bind values) according to `UpdatableRecord.update()` semantics.
`Batch`	`batchUpdate(UpdatableRecord<?>... records)`	Create a batch statement to execute a set of `UPDATE` queries in batch mode (with bind values) according to `UpdatableRecord.update()` semantics.
`Block`	`begin(Collection<? extends Statement> statements)`	Wrap a collection of statements in an anoymous procedural block.
`Block`	`begin(Statement... statements)`	Wrap a collection of statements in an anonymous procedural block.
`int`	`bind(QueryPart part, PreparedStatement stmt)`	Deprecated. - [#2662] - 3.2.0 - Do not reuse this method.
`BindContext`	`bindContext(PreparedStatement stmt)`	Deprecated. - [#6280] - 3.10 - Do not reuse this method.
`void`	`close()`	Close the underlying resources, if any resources have been allocated when constructing this `DSLContext`.
`CommentOnIsStep`	`commentOnColumn(Field<?> field)`	Create a new DSL `COMMENT ON COLUMN` statement.
`CommentOnIsStep`	`commentOnColumn(Name columnName)`	Create a new DSL `COMMENT ON COLUMN` statement.
`CommentOnIsStep`	`commentOnTable(String tableName)`	Create a new DSL `COMMENT ON TABLE` statement.
`CommentOnIsStep`	`commentOnTable(Name tableName)`	Create a new DSL `COMMENT ON TABLE` statement.
`CommentOnIsStep`	`commentOnTable(Table<?> table)`	Create a new DSL `COMMENT ON TABLE` statement.
`CommentOnIsStep`	`commentOnView(String viewName)`	Create a new DSL `COMMENT ON VIEW` statement.
`CommentOnIsStep`	`commentOnView(Name viewName)`	Create a new DSL `COMMENT ON VIEW` statement.
`CommentOnIsStep`	`commentOnView(Table<?> view)`	Create a new DSL `COMMENT ON VIEW` statement.
`void`	`connection(ConnectionRunnable runnable)`	Run a `ConnectionRunnable` in the context of this `DSLContext`'s underlying `Scope.configuration()`'s `Configuration.connectionProvider()`.
`<T> T`	`connectionResult(ConnectionCallable<T> callable)`	Run a `ConnectionCallable` in the context of this `DSLContext`'s underlying `Scope.configuration()`'s `Configuration.connectionProvider()`.
`CreateTableColumnStep`	`createGlobalTemporaryTable(String table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`CreateTableColumnStep`	`createGlobalTemporaryTable(Name table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`CreateTableColumnStep`	`createGlobalTemporaryTable(Table<?> table)`	Create a new DSL `CREATE GLOBAL TEMPORARY TABLE` statement.
`CreateIndexStep`	`createIndex()`	Create a new DSL `CREATE INDEX` statement.
`CreateIndexStep`	`createIndex(String index)`	Create a new DSL `CREATE INDEX` statement.
`CreateIndexStep`	`createIndex(Index index)`	Create a new DSL `CREATE INDEX` statement.
`CreateIndexStep`	`createIndex(Name index)`	Create a new DSL `CREATE INDEX` statement.
`CreateIndexStep`	`createIndexIfNotExists(String index)`	Create a new DSL `CREATE INDEX IF NOT EXISTS` statement.
`CreateIndexStep`	`createIndexIfNotExists(Index index)`	Create a new DSL `CREATE INDEX IF NOT EXISTS` statement.
`CreateIndexStep`	`createIndexIfNotExists(Name index)`	Create a new DSL `CREATE INDEX IF NOT EXISTS` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(String view, String... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(String view, BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(String view, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Name view, BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Name view, Name... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Table<?> view, BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Table<?> view, Field<?>... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateSchemaFinalStep`	`createSchema(String schema)`	Create a new DSL `CREATE SCHEMA` statement.
`CreateSchemaFinalStep`	`createSchema(Name schema)`	Create a new DSL `CREATE SCHEMA` statement.
`CreateSchemaFinalStep`	`createSchema(Schema schema)`	Create a new DSL `CREATE SCHEMA` statement.
`CreateSchemaFinalStep`	`createSchemaIfNotExists(String schema)`	Create a new DSL `CREATE SCHEMA` statement.
`CreateSchemaFinalStep`	`createSchemaIfNotExists(Name schema)`	Create a new DSL `CREATE SCHEMA` statement.
`CreateSchemaFinalStep`	`createSchemaIfNotExists(Schema schema)`	Create a new DSL `CREATE SCHEMA` statement.
`CreateSequenceFlagsStep`	`createSequence(String sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`CreateSequenceFlagsStep`	`createSequence(Name sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`CreateSequenceFlagsStep`	`createSequence(Sequence<?> sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`CreateSequenceFlagsStep`	`createSequenceIfNotExists(String sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`CreateSequenceFlagsStep`	`createSequenceIfNotExists(Name sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`CreateSequenceFlagsStep`	`createSequenceIfNotExists(Sequence<?> sequence)`	Create a new DSL `CREATE SEQUENCE` statement.
`CreateTableColumnStep`	`createTable(String table)`	Create a new DSL `CREATE TABLE` statement.
`CreateTableColumnStep`	`createTable(Name table)`	Create a new DSL `CREATE TABLE` statement.
`CreateTableColumnStep`	`createTable(Table<?> table)`	Create a new DSL `CREATE TABLE` statement.
`CreateTableColumnStep`	`createTableIfNotExists(String table)`	Create a new DSL `CREATE TABLE` statement.
`CreateTableColumnStep`	`createTableIfNotExists(Name table)`	Create a new DSL `CREATE TABLE` statement.
`CreateTableColumnStep`	`createTableIfNotExists(Table<?> table)`	Create a new DSL `CREATE TABLE` statement.
`CreateTableColumnStep`	`createTemporaryTable(String table)`	Create a new DSL `CREATE TEMPORARY TABLE` statement.
`CreateTableColumnStep`	`createTemporaryTable(Name table)`	Create a new DSL `CREATE TEMPORARY TABLE` statement.
`CreateTableColumnStep`	`createTemporaryTable(Table<?> table)`	Create a new DSL `CREATE TEMPORARY TABLE` statement.
`CreateTypeStep`	`createType(String type)`	Create a new DSL `CREATE TYPE` statement.
`CreateTypeStep`	`createType(Name type)`	Create a new DSL `CREATE TYPE` statement.
`CreateIndexStep`	`createUniqueIndex()`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateIndexStep`	`createUniqueIndex(String index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateIndexStep`	`createUniqueIndex(Index index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateIndexStep`	`createUniqueIndex(Name index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateIndexStep`	`createUniqueIndexIfNotExists(String index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateIndexStep`	`createUniqueIndexIfNotExists(Index index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateIndexStep`	`createUniqueIndexIfNotExists(Name index)`	Create a new DSL `CREATE UNIQUE INDEX` statement.
`CreateViewAsStep<Record>`	`createView(String view, String... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(String view, BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(String view, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Name view, BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Name view, Name... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Table<?> view, BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Table<?> view, Field<?>... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(String view, String... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(String view, BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(String view, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Name view, BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Name view, Function<? super Field<?>,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Name view, Name... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Table<?> view, BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Table<?> view, Function<? super Field<?>,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Table<?> view, Field<?>... fields)`	Create a new DSL `CREATE VIEW` statement.
`BigInteger`	`currval(String sequence)`	Convenience method to fetch the CURRVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`BigInteger`	`currval(Name sequence)`	Convenience method to fetch the CURRVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`<T extends Number> T`	`currval(Sequence<T> sequence)`	Convenience method to fetch the CURRVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`Queries`	`ddl(Collection<? extends Table<?>> tables)`	Generate the complete creation script for tables.
`Queries`	`ddl(Collection<? extends Table<?>> tables, DDLExportConfiguration configuration)`	Generate the complete creation script for tables.
`Queries`	`ddl(Collection<? extends Table<?>> tables, DDLFlag... flags)`	Generate the complete creation script for tables.
`Queries`	`ddl(Catalog catalog)`	Generate the complete creation script for the entire catalog.
`Queries`	`ddl(Catalog schema, DDLExportConfiguration configuration)`	Generate a partial creation script for the entire catalog.
`Queries`	`ddl(Catalog schema, DDLFlag... flags)`	Generate a partial creation script for the entire catalog.
`Queries`	`ddl(Schema schema)`	Generate the complete creation script for the entire schema.
`Queries`	`ddl(Schema schema, DDLExportConfiguration configuration)`	Generate a partial creation script for the entire schema.
`Queries`	`ddl(Schema schema, DDLFlag... flags)`	Generate a partial creation script for the entire schema.
`Queries`	`ddl(Table<?> table)`	Generate the complete creation script for a table.
`Queries`	`ddl(Table<?>... tables)`	Generate the complete creation script for tables.
`Queries`	`ddl(Table<?>[] tables, DDLExportConfiguration configuration)`	Generate the complete creation script for tables.
`Queries`	`ddl(Table<?>[] tables, DDLFlag... flags)`	Generate the complete creation script for tables.
`Queries`	`ddl(Table<?> table, DDLExportConfiguration configuration)`	Generate a partial creation script for a table.
`Queries`	`ddl(Table<?> table, DDLFlag... flags)`	Generate a partial creation script for a table.
`<R extends Record> DeleteWhereStep<R>`	`delete(Table<R> table)`	Create a new DSL delete statement.
`<R extends Record> DeleteWhereStep<R>`	`deleteFrom(Table<R> table)`	Create a new DSL delete statement.
`<R extends Record> DeleteQuery<R>`	`deleteQuery(Table<R> table)`	Create a new `DeleteQuery`
`Connection`	`diagnosticsConnection()`	A JDBC connection that proxies the underlying connection to run the jOOQ Diagnostics Pack on executed queries.
`DataSource`	`diagnosticsDataSource()`	A JDBC connection that proxies the underlying connection to run the jOOQ Diagnostics Pack on executed queries.
`DropIndexOnStep`	`dropIndex(String index)`	Create a new DSL `DROP INDEX` statement.
`DropIndexOnStep`	`dropIndex(Index index)`	Create a new DSL `DROP INDEX` statement.
`DropIndexOnStep`	`dropIndex(Name index)`	Create a new DSL `DROP INDEX` statement.
`DropIndexOnStep`	`dropIndexIfExists(String index)`	Create a new DSL `DROP INDEX IF EXISTS` statement.
`DropIndexOnStep`	`dropIndexIfExists(Index index)`	Create a new DSL `DROP INDEX IF EXISTS` statement.
`DropIndexOnStep`	`dropIndexIfExists(Name index)`	Create a new DSL `DROP INDEX IF EXISTS` statement.
`DropSchemaStep`	`dropSchema(String schema)`	Create a new DSL `DROP SCHEMA` statement.
`DropSchemaStep`	`dropSchema(Name schema)`	Create a new DSL `DROP SCHEMA` statement.
`DropSchemaStep`	`dropSchema(Schema schema)`	Create a new DSL `DROP SCHEMA` statement.
`DropSchemaStep`	`dropSchemaIfExists(String schema)`	Create a new DSL `DROP SCHEMA` statement.
`DropSchemaStep`	`dropSchemaIfExists(Name schema)`	Create a new DSL `DROP SCHEMA` statement.
`DropSchemaStep`	`dropSchemaIfExists(Schema schema)`	Create a new DSL `DROP SCHEMA` statement.
`DropSequenceFinalStep`	`dropSequence(String sequence)`	Create a new DSL `DROP SEQUENCE` statement.
`DropSequenceFinalStep`	`dropSequence(Name sequence)`	Create a new DSL `DROP SEQUENCE` statement.
`DropSequenceFinalStep`	`dropSequence(Sequence<?> sequence)`	Create a new DSL `DROP SEQUENCE` statement.
`DropSequenceFinalStep`	`dropSequenceIfExists(String sequence)`	Create a new DSL `DROP SEQUENCE IF EXISTS` statement.
`DropSequenceFinalStep`	`dropSequenceIfExists(Name sequence)`	Create a new DSL `DROP SEQUENCE IF EXISTS` statement.
`DropSequenceFinalStep`	`dropSequenceIfExists(Sequence<?> sequence)`	Create a new DSL `DROP SEQUENCE IF EXISTS` statement.
`DropTableStep`	`dropTable(String table)`	Create a new DSL `DROP TABLE` statement.
`DropTableStep`	`dropTable(Name table)`	Create a new DSL `DROP TABLE` statement.
`DropTableStep`	`dropTable(Table<?> table)`	Create a new DSL `DROP TABLE` statement.
`DropTableStep`	`dropTableIfExists(String table)`	Create a new DSL `DROP TABLE IF EXISTS` statement.
`DropTableStep`	`dropTableIfExists(Name table)`	Create a new DSL `DROP TABLE IF EXISTS` statement.
`DropTableStep`	`dropTableIfExists(Table<?> table)`	Create a new DSL `DROP TABLE IF EXISTS` statement.
`DropTableStep`	`dropTemporaryTable(String table)`	Create a new DSL `DROP TEMPORARY TABLE` statement.
`DropTableStep`	`dropTemporaryTable(Name table)`	Create a new DSL `DROP TEMPORARY TABLE` statement.
`DropTableStep`	`dropTemporaryTable(Table<?> table)`	Create a new DSL `DROP TEMPORARY TABLE` statement.
`DropTypeStep`	`dropType(String type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropType(String... type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropType(Collection<?> type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropType(Name type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropType(Name... type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(String type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(String... type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(Collection<?> type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(Name type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(Name... type)`	Create a new DSL `DROP TYPE` statement.
`DropViewFinalStep`	`dropView(String view)`	Create a new DSL `DROP VIEW` statement.
`DropViewFinalStep`	`dropView(Name view)`	Create a new DSL `DROP VIEW` statement.
`DropViewFinalStep`	`dropView(Table<?> view)`	Create a new DSL `DROP VIEW` statement.
`DropViewFinalStep`	`dropViewIfExists(String view)`	Create a new DSL `DROP VIEW IF EXISTS` statement.
`DropViewFinalStep`	`dropViewIfExists(Name view)`	Create a new DSL `DROP VIEW IF EXISTS` statement.
`DropViewFinalStep`	`dropViewIfExists(Table<?> view)`	Create a new DSL `DROP VIEW IF EXISTS` statement.
`int`	`execute(String sql)`	Execute a query holding plain SQL.
`int`	`execute(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`int`	`execute(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`int`	`execute(Query query)`	Execute a `Query` in the context of this `DSLContext`.
`int`	`execute(SQL sql)`	Execute a query holding plain SQL.
`int`	`executeDelete(TableRecord<?> record, Condition condition)`	Delete a record from a table.
`int`	`executeDelete(UpdatableRecord<?> record)`	Delete a record from a table.
`int`	`executeInsert(TableRecord<?> record)`	Insert one record.
`int`	`executeUpdate(TableRecord<?> record, Condition condition)`	Update a table.
`int`	`executeUpdate(UpdatableRecord<?> record)`	Update a table.
`Explain`	`explain(Query query)`	Run an `EXPLAIN` statement in the database to estimate the cardinality of the query.
`List<Object>`	`extractBindValues(QueryPart part)`	Retrieve the bind values that will be bound by a given `QueryPart`.
`Param<?>`	`extractParam(QueryPart part, String name)`	Get a named parameter from a `QueryPart`, provided its name.
`Map<String,Param<?>>`	`extractParams(QueryPart part)`	Get a `Map` of named parameters.
`Result<Record>`	`fetch(String sql)`	Execute a new query holding plain SQL.
`Result<Record>`	`fetch(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`Result<Record>`	`fetch(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Result<Record>`	`fetch(ResultSet rs)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`Result<Record>`	`fetch(ResultSet rs, Class<?>... types)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`Result<Record>`	`fetch(ResultSet rs, DataType<?>... types)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`Result<Record>`	`fetch(ResultSet rs, Field<?>... fields)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`<R extends Record> Result<R>`	`fetch(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return results.
`Result<Record>`	`fetch(SQL sql)`	Execute a new query holding plain SQL.
`<R extends Record> Result<R>`	`fetch(Table<R> table)`	Execute and return all records for
`<R extends Record> Result<R>`	`fetch(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return all records for
`<R extends Record> Result<R>`	`fetch(Table<R> table, Condition condition)`	Execute and return all records for
`<R extends Record> Result<R>`	`fetch(Table<R> table, Condition... conditions)`	Execute and return all records for
`<R extends Record> R`	`fetchAny(Table<R> table)`	Execute and return zero or one record for
`<R extends Record> R`	`fetchAny(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return zero or one record for
`<R extends Record> R`	`fetchAny(Table<R> table, Condition condition)`	Execute and return zero or one record for
`<R extends Record> R`	`fetchAny(Table<R> table, Condition... conditions)`	Execute and return zero or one record for
`CompletionStage<Result<Record>>`	`fetchAsync(String sql)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(String sql, Object... bindings)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(String sql, QueryPart... parts)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(ResultSet rs)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(ResultSet rs, Class<?>... types)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(ResultSet rs, DataType<?>... types)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(ResultSet rs, Field<?>... fields)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, String sql)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, String sql, Object... bindings)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, String sql, QueryPart... parts)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, ResultSet rs)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, ResultSet rs, Class<?>... types)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, ResultSet rs, DataType<?>... types)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, ResultSet rs, Field<?>... fields)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Executor executor, ResultQuery<R> query)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`CompletionStage<Result<Record>>`	`fetchAsync(Executor executor, SQL sql)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Executor executor, Table<R> table)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Executor executor, Table<R> table, Collection<? extends Condition> conditions)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Executor executor, Table<R> table, Condition condition)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Executor executor, Table<R> table, Condition... conditions)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(ResultQuery<R> query)`	Fetch results in a new `CompletionStage`.
`CompletionStage<Result<Record>>`	`fetchAsync(SQL sql)`	Fetch results in a new `CompletionStage`.
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Table<R> table)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Table<R> table, Collection<? extends Condition> condition)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Table<R> table, Condition condition)`	Execute and return all records asynchronously for
`<R extends Record> CompletionStage<Result<R>>`	`fetchAsync(Table<R> table, Condition... condition)`	Execute and return all records asynchronously for
`<R extends TableRecord<R>> Result<R>`	`fetchByExample(R example)`	Execute a "Query by Example" (QBE) based on an example record.
`int`	`fetchCount(Select<?> query)`	Execute a `Select` query in the context of this `DSLContext` and return a `COUNT(*)` value.
`int`	`fetchCount(Table<?> table)`	Count the number of records in a table.
`int`	`fetchCount(Table<?> table, Collection<? extends Condition> conditions)`	Count the number of records in a table that satisfy a condition.
`int`	`fetchCount(Table<?> table, Condition condition)`	Count the number of records in a table that satisfy a condition.
`int`	`fetchCount(Table<?> table, Condition... conditions)`	Count the number of records in a table that satisfy a condition.
`boolean`	`fetchExists(Select<?> query)`	Check if a `Select` would return any records, if it were executed.
`boolean`	`fetchExists(Table<?> table)`	Check if a table has any records.
`boolean`	`fetchExists(Table<?> table, Collection<? extends Condition> conditions)`	Check if a table has any records that satisfy a condition.
`boolean`	`fetchExists(Table<?> table, Condition condition)`	Check if a table has any records that satisfy a condition.
`boolean`	`fetchExists(Table<?> table, Condition... conditions)`	Check if a table has any records that satisfy a condition.
`Result<Record>`	`fetchFromCSV(String string)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromCSV(String string, boolean header)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromCSV(String string, boolean header, char delimiter)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromCSV(String string, char delimiter)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromHTML(String string)`	Convert an HTML table into a jOOQ `Result`.
`Result<Record>`	`fetchFromJSON(String string)`	Fetch all data from a JSON string.
`Result<Record>`	`fetchFromStringData(String[]... data)`	Fetch all data from a list of strings.
`Result<Record>`	`fetchFromStringData(List<String[]> data)`	Fetch all data from a list of strings.
`Result<Record>`	`fetchFromStringData(List<String[]> data, boolean header)`	Fetch all data from a list of strings.
`Result<Record>`	`fetchFromTXT(String string)`	Fetch all data from a formatted string.
`Result<Record>`	`fetchFromTXT(String string, String nullLiteral)`	Fetch all data from a formatted string.
`Result<Record>`	`fetchFromXML(String string)`	Fetch all data from an XML string.
`Cursor<Record>`	`fetchLazy(String sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Cursor<Record>`	`fetchLazy(String sql, Object... bindings)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Cursor<Record>`	`fetchLazy(String sql, QueryPart... parts)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Cursor<Record>`	`fetchLazy(ResultSet rs)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`Cursor<Record>`	`fetchLazy(ResultSet rs, Class<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`Cursor<Record>`	`fetchLazy(ResultSet rs, DataType<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`Cursor<Record>`	`fetchLazy(ResultSet rs, Field<?>... fields)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`<R extends Record> Cursor<R>`	`fetchLazy(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a cursor.
`Cursor<Record>`	`fetchLazy(SQL sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`<R extends Record> Cursor<R>`	`fetchLazy(Table<R> table)`	Execute and return all records lazily for
`<R extends Record> Cursor<R>`	`fetchLazy(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return all records lazily for
`<R extends Record> Cursor<R>`	`fetchLazy(Table<R> table, Condition condition)`	Execute and return all records lazily for
`<R extends Record> Cursor<R>`	`fetchLazy(Table<R> table, Condition... conditions)`	Execute and return all records lazily for
`Results`	`fetchMany(String sql)`	Execute a new query holding plain SQL, possibly returning several result sets.
`Results`	`fetchMany(String sql, Object... bindings)`	Execute a new query holding plain SQL, possibly returning several result sets.
`Results`	`fetchMany(String sql, QueryPart... parts)`	Execute a new query holding plain SQL, possibly returning several result sets.
`<R extends Record> Results`	`fetchMany(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a cursor.
`Results`	`fetchMany(SQL sql)`	Execute a new query holding plain SQL, possibly returning several result sets.
`Record`	`fetchOne(String sql)`	Execute a new query holding plain SQL.
`Record`	`fetchOne(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`Record`	`fetchOne(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Record`	`fetchOne(ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchOne(ResultSet rs, Class<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchOne(ResultSet rs, DataType<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchOne(ResultSet rs, Field<?>... fields)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`<R extends Record> R`	`fetchOne(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a record.
`Record`	`fetchOne(SQL sql)`	Execute a new query holding plain SQL.
`<R extends Record> R`	`fetchOne(Table<R> table)`	Execute and return zero or one record for
`<R extends Record> R`	`fetchOne(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return zero or one record for
`<R extends Record> R`	`fetchOne(Table<R> table, Condition condition)`	Execute and return zero or one record for
`<R extends Record> R`	`fetchOne(Table<R> table, Condition... conditions)`	Execute and return zero or one record for
`Optional<Record>`	`fetchOptional(String sql)`	Execute a new query holding plain SQL.
`Optional<Record>`	`fetchOptional(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`Optional<Record>`	`fetchOptional(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Optional<Record>`	`fetchOptional(ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Optional<Record>`	`fetchOptional(ResultSet rs, Class<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Optional<Record>`	`fetchOptional(ResultSet rs, DataType<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Optional<Record>`	`fetchOptional(ResultSet rs, Field<?>... fields)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`<R extends Record> Optional<R>`	`fetchOptional(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a record.
`Optional<Record>`	`fetchOptional(SQL sql)`	Execute a new query holding plain SQL.
`<R extends Record> Optional<R>`	`fetchOptional(Table<R> table)`	Execute and return zero or one record for
`<R extends Record> Optional<R>`	`fetchOptional(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return zero or one record for
`<R extends Record> Optional<R>`	`fetchOptional(Table<R> table, Condition condition)`	Execute and return zero or one record for
`<R extends Record> Optional<R>`	`fetchOptional(Table<R> table, Condition... conditions)`	Execute and return zero or one record for
`Optional<?>`	`fetchOptionalValue(String sql)`	Execute a new query holding plain SQL.
`Optional<?>`	`fetchOptionalValue(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`Optional<?>`	`fetchOptionalValue(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Optional<?>`	`fetchOptionalValue(ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> Optional<T>`	`fetchOptionalValue(ResultSet rs, Class<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> Optional<T>`	`fetchOptionalValue(ResultSet rs, DataType<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> Optional<T>`	`fetchOptionalValue(ResultSet rs, Field<T> field)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T,R extends Record1<T>> Optional<T>`	`fetchOptionalValue(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`Optional<?>`	`fetchOptionalValue(SQL sql)`	Execute a new query holding plain SQL.
`<T> Optional<T>`	`fetchOptionalValue(TableField<?,T> field)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`Record`	`fetchSingle(String sql)`	Execute a new query holding plain SQL.
`Record`	`fetchSingle(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`Record`	`fetchSingle(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Record`	`fetchSingle(ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(ResultSet rs, Class<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(ResultSet rs, DataType<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(ResultSet rs, Field<?>... fields)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(Collection<? extends SelectField<?>> fields)`	Execute and return exactly one record for
`<R extends Record> R`	`fetchSingle(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a record.
`Record`	`fetchSingle(SelectField<?>... fields)`	Execute and return exactly one record for
`<T1> Record1<T1>`	`fetchSingle(SelectField<T1> field1)`	Execute and return exactly one record for
`<T1,T2> Record2<T1,T2>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2)`	Execute and return exactly one record for
`<T1,T2,T3> Record3<T1,T2,T3>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3)`	Execute and return exactly one record for
`<T1,T2,T3,T4> Record4<T1,T2,T3,T4>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5> Record5<T1,T2,T3,T4,T5>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6> Record6<T1,T2,T3,T4,T5,T6>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7> Record7<T1,T2,T3,T4,T5,T6,T7>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8> Record8<T1,T2,T3,T4,T5,T6,T7,T8>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9> Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>`	`fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18)`	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>`	fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19)	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>`	fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20)	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>`	fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21)	Execute and return exactly one record for
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>`	fetchSingle(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22)	Execute and return exactly one record for
`Record`	`fetchSingle(SQL sql)`	Execute a new query holding plain SQL.
`<R extends Record> R`	`fetchSingle(Table<R> table)`	Execute and return exactly one record for
`<R extends Record> R`	`fetchSingle(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return exactly one record for
`<R extends Record> R`	`fetchSingle(Table<R> table, Condition condition)`	Execute and return exactly one record for
`<R extends Record> R`	`fetchSingle(Table<R> table, Condition... conditions)`	Execute and return exactly one record for
`Stream<Record>`	`fetchStream(String sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Stream<Record>`	`fetchStream(String sql, Object... bindings)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Stream<Record>`	`fetchStream(String sql, QueryPart... parts)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Stream<Record>`	`fetchStream(ResultSet rs)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`Stream<Record>`	`fetchStream(ResultSet rs, Class<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`Stream<Record>`	`fetchStream(ResultSet rs, DataType<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`Stream<Record>`	`fetchStream(ResultSet rs, Field<?>... fields)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`<R extends Record> Stream<R>`	`fetchStream(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a stream.
`Stream<Record>`	`fetchStream(SQL sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`<R extends Record> Stream<R>`	`fetchStream(Table<R> table)`	Execute and return all records lazily for
`<R extends Record> Stream<R>`	`fetchStream(Table<R> table, Collection<? extends Condition> conditions)`	Execute and return all records lazily for
`<R extends Record> Stream<R>`	`fetchStream(Table<R> table, Condition condition)`	Execute and return all records lazily for
`<R extends Record> Stream<R>`	`fetchStream(Table<R> table, Condition... conditions)`	Execute and return all records lazily for
`Object`	`fetchValue(String sql)`	Execute a new query holding plain SQL.
`Object`	`fetchValue(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`Object`	`fetchValue(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Object`	`fetchValue(ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(ResultSet rs, Class<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(ResultSet rs, DataType<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(ResultSet rs, Field<T> field)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(Field<T> field)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`<T,R extends Record1<T>> T`	`fetchValue(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`Object`	`fetchValue(SQL sql)`	Execute a new query holding plain SQL.
`<T> T`	`fetchValue(Table<? extends Record1<T>> table)`	Fetch a single value from a single column table.
`<T> T`	`fetchValue(TableField<?,T> field)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`List<?>`	`fetchValues(String sql)`	Execute a new query holding plain SQL.
`List<?>`	`fetchValues(String sql, Object... bindings)`	Execute a new query holding plain SQL.
`List<?>`	`fetchValues(String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`List<?>`	`fetchValues(ResultSet rs)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T> List<T>`	`fetchValues(ResultSet rs, Class<T> type)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T> List<T>`	`fetchValues(ResultSet rs, DataType<T> type)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T> List<T>`	`fetchValues(ResultSet rs, Field<T> field)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T,R extends Record1<T>> List<T>`	`fetchValues(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return all values for the only column.
`List<?>`	`fetchValues(SQL sql)`	Execute a new query holding plain SQL.
`<T> List<T>`	`fetchValues(Table<? extends Record1<T>> table)`	Fetch all values from a single column table.
`<T> List<T>`	`fetchValues(TableField<?,T> field)`	Fetch all values in a given `Table`'s `TableField`.
`GrantOnStep`	`grant(Collection<? extends Privilege> privileges)`	Grant privileges on a table to user or role.
`GrantOnStep`	`grant(Privilege privilege)`	Grant a privilege on a table to user or role.
`GrantOnStep`	`grant(Privilege... privileges)`	Grant privileges on a table to user or role.
`InformationSchema`	`informationSchema(Catalog catalog)`	Export a catalog to the `InformationSchema` format.
`InformationSchema`	`informationSchema(Catalog... catalogs)`	Export a set of catalogs to the `InformationSchema` format.
`InformationSchema`	`informationSchema(Schema schema)`	Export a schema to the `InformationSchema` format.
`InformationSchema`	`informationSchema(Schema... schemas)`	Export a set of schemas to the `InformationSchema` format.
`InformationSchema`	`informationSchema(Table<?> table)`	Export a table to the `InformationSchema` format.
`InformationSchema`	`informationSchema(Table<?>... table)`	Export a set of tables to the `InformationSchema` format.
`<R extends Record> InsertSetStep<R>`	`insertInto(Table<R> into)`	Create a new DSL insert statement.
`<R extends Record> InsertValuesStepN<R>`	`insertInto(Table<R> into, Collection<? extends Field<?>> fields)`	Create a new DSL insert statement.
`<R extends Record> InsertValuesStepN<R>`	`insertInto(Table<R> into, Field<?>... fields)`	Create a new DSL insert statement.
`<R extends Record,T1> InsertValuesStep1<R,T1>`	`insertInto(Table<R> into, Field<T1> field1)`	Create a new DSL insert statement.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<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.
`<R extends Record> InsertQuery<R>`	`insertQuery(Table<R> into)`	Create a new `InsertQuery`
`BigInteger`	`lastID()`	Retrieve the last inserted ID.
`<R extends Record> LoaderOptionsStep<R>`	`loadInto(Table<R> table)`	Create a new `Loader` object to load data from a CSV or XML source.
`Schema`	`map(Schema schema)`	Map a schema to another one.
`<R extends Record> Table<R>`	`map(Table<R> table)`	Map a table to another one.
`<R extends Record> MergeUsingStep<R>`	`mergeInto(Table<R> table)`	Create a new DSL SQL standard MERGE statement.
`<R extends Record> MergeKeyStepN<R>`	`mergeInto(Table<R> table, Collection<? extends Field<?>> fields)`	Create a new DSL merge statement (H2-specific syntax).
`<R extends Record> MergeKeyStepN<R>`	`mergeInto(Table<R> table, Field<?>... fields)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1> MergeKeyStep1<R,T1>`	`mergeInto(Table<R> table, Field<T1> field1)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2> MergeKeyStep2<R,T1,T2>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3> MergeKeyStep3<R,T1,T2,T3>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4> MergeKeyStep4<R,T1,T2,T3,T4>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5> MergeKeyStep5<R,T1,T2,T3,T4,T5>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6> MergeKeyStep6<R,T1,T2,T3,T4,T5,T6>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7> MergeKeyStep7<R,T1,T2,T3,T4,T5,T6,T7>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>`	`mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)`	Create a new DSL UPSERT statement (`SQLDialect.H2` `MERGE`) or `SQLDialect.HANA` `UPSERT`).
`Meta`	`meta()`	Access the database meta data.
`Meta`	`meta(DatabaseMetaData meta)`	Access the database meta data from an explicit JDBC `DatabaseMetaData`.
`Meta`	`meta(Catalog... catalogs)`	Access the database meta data from explicit catalog information.
`Meta`	`meta(Schema... schemas)`	Access the database meta data from explicit schema information.
`Meta`	`meta(Source... scripts)`	Access the database meta data for a database represented by a list of DDL scripts.
`Meta`	`meta(Table<?>... tables)`	Access the database meta data from explicit table information.
`Meta`	`meta(InformationSchema schema)`	Access the database meta data from an explicit JAXB-annotated meta model.
`void`	`mock(MockDataProvider provider, MockRunnable mockable)`	Run a `MockRunnable` in the context of this `DSLContext` 's underlying `Scope.configuration()`'s, and of a `MockDataProvider`.
`<T> T`	`mockResult(MockDataProvider provider, MockCallable<T> mockable)`	Run a `MockRunnable` in the context of this `DSLContext` 's underlying `Scope.configuration()`'s, and of a `MockDataProvider` and return the `mockable`'s outcome.
`Record`	`newRecord(Collection<? extends Field<?>> fields)`	Create a new empty `Record`.
`Record`	`newRecord(Field<?>... fields)`	Create a new empty `Record`.
`<T1> Record1<T1>`	`newRecord(Field<T1> field1)`	Create a new empty `Record`.
`<T1,T2> Record2<T1,T2>`	`newRecord(Field<T1> field1, Field<T2> field2)`	Create a new empty `Record`.
`<T1,T2,T3> Record3<T1,T2,T3>`	`newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3)`	Create a new empty `Record`.
`<T1,T2,T3,T4> Record4<T1,T2,T3,T4>`	`newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)`	Create a new empty `Record`.
`<T1,T2,T3,T4,T5> Record5<T1,T2,T3,T4,T5>`	`newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)`	Create a new empty `Record`.
`<T1,T2,T3,T4,T5,T6> Record6<T1,T2,T3,T4,T5,T6>`	`newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)`	Create a new empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7> Record7<T1,T2,T3,T4,T5,T6,T7>`	`newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)`	Create a new empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8> Record8<T1,T2,T3,T4,T5,T6,T7,T8>`	`newRecord(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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9> Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>`	`newRecord(Field<T1> field1, 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 empty `Record`.
`<R extends Record> R`	`newRecord(Table<R> table)`	Create a new `Record` that can be inserted into the corresponding table.
`<R extends Record> R`	`newRecord(Table<R> table, Object source)`	Create a new pre-filled `Record` that can be inserted into the corresponding table.
`<R extends UDTRecord<R>> R`	`newRecord(UDT<R> type)`	Create a new `UDTRecord`.
`Result<Record>`	`newResult(Collection<? extends Field<?>> fields)`	Create a new empty `Record`.
`Result<Record>`	`newResult(Field<?>... fields)`	Create a new empty `Record`.
`<T1> Result<Record1<T1>>`	`newResult(Field<T1> field1)`	Create a new empty `Result`.
`<T1,T2> Result<Record2<T1,T2>>`	`newResult(Field<T1> field1, Field<T2> field2)`	Create a new empty `Result`.
`<T1,T2,T3> Result<Record3<T1,T2,T3>>`	`newResult(Field<T1> field1, Field<T2> field2, Field<T3> field3)`	Create a new empty `Result`.
`<T1,T2,T3,T4> Result<Record4<T1,T2,T3,T4>>`	`newResult(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)`	Create a new empty `Result`.
`<T1,T2,T3,T4,T5> Result<Record5<T1,T2,T3,T4,T5>>`	`newResult(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)`	Create a new empty `Result`.
`<T1,T2,T3,T4,T5,T6> Result<Record6<T1,T2,T3,T4,T5,T6>>`	`newResult(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)`	Create a new empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7> Result<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`newResult(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)`	Create a new empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8> Result<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`newResult(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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9> Result<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Result<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Result<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Result<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Result<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Result<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Result<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Result<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Result<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Result<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Result<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Result<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Result<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Result<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	`newResult(Field<T1> field1, 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 empty `Result`.
`<R extends Record> Result<R>`	`newResult(Table<R> table)`	Create a new empty `Result`.
`BigInteger`	`nextval(String sequence)`	Convenience method to fetch the NEXTVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`BigInteger`	`nextval(Name sequence)`	Convenience method to fetch the NEXTVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`<T extends Number> T`	`nextval(Sequence<T> sequence)`	Convenience method to fetch the NEXTVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`Parser`	`parser()`	Access the parser API.
`Connection`	`parsingConnection()`	A JDBC connection that runs each statement through the `parser()` first, prior to re-generating and running the SQL.
`DataSource`	`parsingDataSource()`	A JDBC data source that runs each statement through the `parser()` first, prior to re-generating and running the SQL.
`Queries`	`queries(Collection<? extends Query> queries)`	Wrap a collection of queries.
`Queries`	`queries(Query... queries)`	Wrap a collection of queries.
`RowCountQuery`	`query(String sql)`	Create a new query holding plain SQL.
`RowCountQuery`	`query(String sql, Object... bindings)`	Create a new query holding plain SQL.
`RowCountQuery`	`query(String sql, QueryPart... parts)`	Create a new query holding plain SQL.
`RowCountQuery`	`query(SQL sql)`	Create a new query holding plain SQL.
`String`	`render(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`.
`RenderContext`	`renderContext()`	Deprecated. - [#6280] - 3.10 - Do not reuse this method.
`String`	`renderInlined(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`, inlining all bind variables.
`String`	`renderNamedOrInlinedParams(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`, rendering bind variables as named parameters, or inlined parameters if they have no name.
`String`	`renderNamedParams(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`, rendering bind variables as named parameters.
`ResultQuery<Record>`	`resultQuery(String sql)`	Create a new query holding plain SQL.
`ResultQuery<Record>`	`resultQuery(String sql, Object... bindings)`	Create a new query holding plain SQL.
`ResultQuery<Record>`	`resultQuery(String sql, QueryPart... parts)`	Create a new query holding plain SQL.
`ResultQuery<Record>`	`resultQuery(SQL sql)`	Create a new query holding plain SQL.
`RevokeOnStep`	`revoke(Collection<? extends Privilege> privileges)`	Revoke privileges on table from user or role.
`RevokeOnStep`	`revoke(Privilege privilege)`	Revoke a privilege on table from user or role.
`RevokeOnStep`	`revoke(Privilege... privileges)`	Revoke privileges on table from user or role.
`RevokeOnStep`	`revokeGrantOptionFor(Collection<? extends Privilege> privileges)`	Revoke grant option for some privileges on a table from user or role.
`RevokeOnStep`	`revokeGrantOptionFor(Privilege privilege)`	Revoke grant option for a privilege on a table from user or role.
`RevokeOnStep`	`revokeGrantOptionFor(Privilege... privileges)`	Revoke grant option for some privileges on a table from user or role.
`SelectSelectStep<Record>`	`select(Collection<? extends SelectFieldOrAsterisk> fields)`	Create a new DSL select statement.
`<T1> SelectSelectStep<Record1<T1>>`	`select(SelectField<T1> field1)`	Create a new DSL select statement.
`<T1,T2> SelectSelectStep<Record2<T1,T2>>`	`select(SelectField<T1> field1, SelectField<T2> field2)`	Create a new DSL select statement.
`<T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3)`	Create a new DSL select statement.
`<T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19)	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20)	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21)	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	select(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22)	Create a new DSL select statement.
`SelectSelectStep<Record>`	`select(SelectFieldOrAsterisk... fields)`	Create a new DSL select statement.
`SelectSelectStep<Record1<Integer>>`	`selectCount()`	Create a new DSL select statement for `COUNT(*)`.
`SelectSelectStep<Record>`	`selectDistinct(Collection<? extends SelectFieldOrAsterisk> fields)`	Create a new DSL select statement.
`<T1> SelectSelectStep<Record1<T1>>`	`selectDistinct(SelectField<T1> field1)`	Create a new DSL select statement.
`<T1,T2> SelectSelectStep<Record2<T1,T2>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2)`	Create a new DSL select statement.
`<T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3)`	Create a new DSL select statement.
`<T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18)`	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19)	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20)	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21)	Create a new DSL select statement.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	selectDistinct(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22)	Create a new DSL select statement.
`SelectSelectStep<Record>`	`selectDistinct(SelectFieldOrAsterisk... fields)`	Create a new DSL select statement.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(String sql)`	Create a new DSL select statement, projecting `*`.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(String sql, Object... bindings)`	Create a new DSL select statement, projecting `*`.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(String sql, QueryPart... parts)`	Create a new DSL select statement, projecting `*`.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(Name table)`	Create a new DSL select statement, projecting `*`.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(SQL sql)`	Create a new DSL select statement, projecting `*`.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(Table<R> table)`	Create a new DSL select statement, projecting the known columns from a table.
`SelectSelectStep<Record1<Integer>>`	`selectOne()`	Create a new DSL select statement for a constant `1` literal.
`SelectQuery<Record>`	`selectQuery()`	Create a new `SelectQuery`
`<R extends Record> SelectQuery<R>`	`selectQuery(TableLike<R> table)`	Create a new `SelectQuery`
`SelectSelectStep<Record1<Integer>>`	`selectZero()`	Create a new DSL select statement for a constant `0` literal.
`RowCountQuery`	`setCatalog(String catalog)`	Set the current catalog to a new value.
`RowCountQuery`	`setCatalog(Catalog catalog)`	Set the current catalog to a new value.
`RowCountQuery`	`setCatalog(Name catalog)`	Set the current catalog to a new value.
`RowCountQuery`	`setSchema(String schema)`	Set the current schema to a new value.
`RowCountQuery`	`setSchema(Name schema)`	Set the current schema to a new value.
`RowCountQuery`	`setSchema(Schema schema)`	Set the current schema to a new value.
`Block`	`statements(Collection<? extends Statement> statements)`	Wrap a collection of statements in an anonymous procedural block that does not wrap in `BEGIN ..`
`Block`	`statements(Statement... statements)`	Wrap a collection of statements in an anonymous procedural block that does not wrap in `BEGIN ..`
`void`	`transaction(ContextTransactionalRunnable transactional)`	Run a `ContextTransactionalRunnable` in the context of this `DSLContext`'s underlying `Scope.configuration()`'s `Configuration.transactionProvider()`.
`void`	`transaction(TransactionalRunnable transactional)`	Run a `TransactionalRunnable` in the context of this `DSLContext`'s underlying `Scope.configuration()`'s `Configuration.transactionProvider()`.
`CompletionStage<Void>`	`transactionAsync(Executor executor, TransactionalRunnable transactional)`	Run a `TransactionalRunnable` asynchronously.
`CompletionStage<Void>`	`transactionAsync(TransactionalRunnable transactional)`	Run a `TransactionalRunnable` asynchronously.
`<T> T`	`transactionResult(ContextTransactionalCallable<T> transactional)`	Run a `ContextTransactionalRunnable` in the context of this `DSLContext`'s underlying `Scope.configuration()`'s `Configuration.transactionProvider()`, and return the `transactional`'s outcome.
`<T> T`	`transactionResult(TransactionalCallable<T> transactional)`	Run a `TransactionalCallable` in the context of this `DSLContext`'s underlying `Scope.configuration()`'s `Configuration.transactionProvider()`, and return the `transactional`'s outcome.
`<T> CompletionStage<T>`	`transactionResultAsync(Executor executor, TransactionalCallable<T> transactional)`	Run a `TransactionalCallable` asynchronously.
`<T> CompletionStage<T>`	`transactionResultAsync(TransactionalCallable<T> transactional)`	Run a `TransactionalCallable` asynchronously.
`TruncateIdentityStep<Record>`	`truncate(String table)`	Create a new DSL truncate statement.
`TruncateIdentityStep<Record>`	`truncate(Name table)`	Create a new DSL truncate statement.
`<R extends Record> TruncateIdentityStep<R>`	`truncate(Table<R> table)`	Create a new DSL truncate statement.
`TruncateIdentityStep<Record>`	`truncateTable(String table)`	Create a new DSL truncate statement.
`TruncateIdentityStep<Record>`	`truncateTable(Name table)`	Create a new DSL truncate statement.
`<R extends Record> TruncateIdentityStep<R>`	`truncateTable(Table<R> table)`	Create a new DSL truncate statement.
`<R extends Record> UpdateSetFirstStep<R>`	`update(Table<R> table)`	Create a new DSL update statement.
`<R extends Record> UpdateQuery<R>`	`updateQuery(Table<R> table)`	Create a new `UpdateQuery`
`WithAsStep`	`with(String alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep1`	`with(String alias, String fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(String alias, String... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep2`	`with(String alias, String fieldAlias1, String fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep3`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep4`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep5`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep6`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep7`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep8`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep9`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep10`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep11`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep12`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep13`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep14`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep15`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep16`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep17`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep18`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep19`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep20`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep21`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep22`	`with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(String alias, BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(String alias, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithStep`	`with(CommonTableExpression<?>... tables)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(Name alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep1`	`with(Name alias, Name fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(Name alias, Name... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep2`	`with(Name alias, Name fieldAlias1, Name fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep3`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep4`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep5`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep6`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep7`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep8`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep9`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep10`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep11`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep12`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep13`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep14`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep15`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep16`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep17`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep18`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep19`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep20`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep21`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep22`	`with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(String alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep1`	`withRecursive(String alias, String fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(String alias, String... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep2`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep3`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep4`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep5`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep6`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep7`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep8`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep9`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep10`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep11`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep12`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep13`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep14`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep15`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep16`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep17`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep18`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep19`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep20`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep21`	`withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep22`	withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(String alias, BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(String alias, Function<? super Field<?>,? extends String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithStep`	`withRecursive(CommonTableExpression<?>... tables)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(Name alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep1`	`withRecursive(Name alias, Name fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(Name alias, Name... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep2`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep3`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep4`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep5`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep6`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep7`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep8`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep9`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep10`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep11`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep12`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep13`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep14`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep15`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep16`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep17`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep18`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep19`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep20`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep21`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep22`	`withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.

Methods inherited from interface org.jooq.Scope
configuration, data, data, data, dialect, dsl, family, settings

Method Detail

close
```
void close()
    throws DataAccessException
```
Close the underlying resources, if any resources have been allocated when constructing this DSLContext.
Some DSLContext constructors, such as DSL.using(String), DSL.using(String, Properties), or DSL.using(String, String, String) allocate a Connection resource, which is inaccessible to the outside of the DSLContext implementation. Proper resource management must thus be done via this close() method.

Specified by:

close in interface AutoCloseable

Throws:

DataAccessException - When something went wrong closing the underlying resources.

map
```
Schema map(Schema schema)
```
Map a schema to another one.
This will map a schema onto another one, depending on configured schema mapping in this DSLContext. If no applicable schema mapping can be found, the schema itself is returned.

Parameters:

schema - A schema

Returns:

The mapped schema

map
```
<R extends Record> Table<R> map(Table<R> table)
```
Map a table to another one.
This will map a table onto another one, depending on configured table mapping in this DSLContext. If no applicable table mapping can be found, the table itself is returned.

Parameters:

table - A table

Returns:

The mapped table

parser
```
Parser parser()
```
Access the parser API.
This is experimental functionality.

parsingConnection
```
Connection parsingConnection()
```
A JDBC connection that runs each statement through the parser() first, prior to re-generating and running the SQL.
The resulting Connection wraps an underlying JDBC connection that has been obtained from ConnectionProvider.acquire() and must be released by calling Connection.close().
This is experimental functionality:
- While this works well for static Statement executions, bind variables and their position calculation might cause issues when the generated SQL output involves more complex SQL transformation. See also https://github.com/jOOQ/jOOQ/issues/5759.
- Batching statements is currently not supported. See also https://github.com/jOOQ/jOOQ/issues/5757.

parsingDataSource
```
DataSource parsingDataSource()
```
A JDBC data source that runs each statement through the parser() first, prior to re-generating and running the SQL.
This simply wraps the parsingConnection() in a DataSource.

diagnosticsConnection
```
Connection diagnosticsConnection()
```
A JDBC connection that proxies the underlying connection to run the jOOQ Diagnostics Pack on executed queries.
This is experimental functionality.

diagnosticsDataSource
```
DataSource diagnosticsDataSource()
```
A JDBC connection that proxies the underlying connection to run the jOOQ Diagnostics Pack on executed queries.
This simply wraps the diagnosticsConnection() in a DataSource.

meta
```
Meta meta()
```
Access the database meta data.
This method returns meta information provided by Configuration.metaProvider(), which defaults to a wrapper type that gives access to your JDBC connection's DatabaseMetaData as obtained from your ConnectionProvider.

See Also:

meta(DatabaseMetaData)

meta
```
Meta meta(DatabaseMetaData meta)
```
Access the database meta data from an explicit JDBC DatabaseMetaData.

meta
```
Meta meta(Catalog... catalogs)
```
Access the database meta data from explicit catalog information.
This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta
```
Meta meta(Schema... schemas)
```
Access the database meta data from explicit schema information.
This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta
```
Meta meta(Table<?>... tables)
```
Access the database meta data from explicit table information.
This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta
```
Meta meta(InformationSchema schema)
```
Access the database meta data from an explicit JAXB-annotated meta model.
This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta
```
@Internal
Meta meta(Source... scripts)
```
Access the database meta data for a database represented by a list of DDL scripts. The DDL scripts will be parsed using parser(), which in turn uses the relevant settings (e.g. Settings.getParseDialect()) of this object.
This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).
This method is for internal only. Do not reference directly.

informationSchema
```
InformationSchema informationSchema(Catalog catalog)
```
Export a catalog to the InformationSchema format.
This allows for serialising schema meta information as XML using JAXB. See also Constants.XSD_META for details.

informationSchema
```
InformationSchema informationSchema(Catalog... catalogs)
```
Export a set of catalogs to the InformationSchema format.
This allows for serialising schema meta information as XML using JAXB. See also Constants.XSD_META for details.

informationSchema
```
InformationSchema informationSchema(Schema schema)
```
Export a schema to the InformationSchema format.
This allows for serialising schema meta information as XML using JAXB. See also Constants.XSD_META for details.

informationSchema
```
InformationSchema informationSchema(Schema... schemas)
```
Export a set of schemas to the InformationSchema format.
This allows for serialising schema meta information as XML using JAXB. See also Constants.XSD_META for details.

informationSchema
```
InformationSchema informationSchema(Table<?> table)
```
Export a table to the InformationSchema format.
Exporting a single table will not include any foreign key definitions in the exported data.
This allows for serialising schema meta information as XML using JAXB. See also Constants.XSD_META for details.

informationSchema
```
InformationSchema informationSchema(Table<?>... table)
```
Export a set of tables to the InformationSchema format.
Only those foreign keys whose referenced table is also included in the export will be exported.
This allows for serialising schema meta information as XML using JAXB. See also Constants.XSD_META for details.

explain

@Support({AURORA_MYSQL,AURORA_POSTGRES,H2,HSQLDB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE})
Explain explain(Query query)

Run an EXPLAIN statement in the database to estimate the cardinality of the query.

transactionResult
```
<T> T transactionResult(TransactionalCallable<T> transactional)
```
Run a TransactionalCallable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and return the transactional's outcome.
The argument transactional code should not capture any scope but derive its Configuration from the TransactionalCallable.run(Configuration) argument in order to create new statements.

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

RuntimeException - any runtime exception thrown by the transactional logic, indicating that a rollback has occurred.

DataAccessException - any database problem that may have arised when executing the transactional logic, or a wrapper for any checked exception thrown by the transactional logic, indicating that a rollback has occurred.

transactionResult
```
<T> T transactionResult(ContextTransactionalCallable<T> transactional)
                 throws ConfigurationException
```
Run a ContextTransactionalRunnable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and return the transactional's outcome.
The argument transactional code may capture scope to derive its Configuration from the "context" in order to create new statements. This context can be provided, for instance, by ThreadLocalTransactionProvider automatically.

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

ConfigurationException - if the underlying Configuration.transactionProvider() is not able to provide context (i.e. currently, it is not a ThreadLocalTransactionProvider).

RuntimeException - any runtime exception thrown by the transactional logic, indicating that a rollback has occurred.

DataAccessException - any database problem that may have arised when executing the transactional logic, or a wrapper for any checked exception thrown by the transactional logic, indicating that a rollback has occurred.

transaction
```
void transaction(TransactionalRunnable transactional)
```
Run a TransactionalRunnable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider().
The argument transactional code should not capture any scope but derive its Configuration from the TransactionalCallable.run(Configuration) argument in order to create new statements.

Parameters:

transactional - The transactional code

Throws:

RuntimeException - any runtime exception thrown by the transactional logic, indicating that a rollback has occurred.

DataAccessException - any database problem that may have arised when executing the transactional logic, or a wrapper for any checked exception thrown by the transactional logic, indicating that a rollback has occurred.

transaction
```
void transaction(ContextTransactionalRunnable transactional)
          throws ConfigurationException
```
Run a ContextTransactionalRunnable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider().
The argument transactional code may capture scope to derive its Configuration from the "context" in order to create new statements. This context can be provided, for instance, by ThreadLocalTransactionProvider automatically.

Parameters:

transactional - The transactional code

Throws:

ConfigurationException - if the underlying Configuration.transactionProvider() is not able to provide context (i.e. currently, it is not a ThreadLocalTransactionProvider).

RuntimeException - any runtime exception thrown by the transactional logic, indicating that a rollback has occurred.

DataAccessException - any database problem that may have arised when executing the transactional logic, or a wrapper for any checked exception thrown by the transactional logic, indicating that a rollback has occurred.

transactionResultAsync
```
<T> CompletionStage<T> transactionResultAsync(TransactionalCallable<T> transactional)
                                       throws ConfigurationException
```
Run a TransactionalCallable asynchronously.
The TransactionCallable is run in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and returns the transactional's outcome in a new CompletionStage that is asynchronously completed by a task run by an Executor provided by the underlying Scope.configuration()'s Configuration.executorProvider().

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

transactionAsync
```
CompletionStage<Void> transactionAsync(TransactionalRunnable transactional)
                                throws ConfigurationException
```
Run a TransactionalRunnable asynchronously.
The TransactionRunnable is run in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and returns the transactional's outcome in a new CompletionStage that is asynchronously completed by a task run by an Executor provided by the underlying Scope.configuration()'s Configuration.executorProvider().

Parameters:

transactional - The transactional code

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

transactionResultAsync
```
<T> CompletionStage<T> transactionResultAsync(Executor executor,
                                              TransactionalCallable<T> transactional)
                                       throws ConfigurationException
```
Run a TransactionalCallable asynchronously.
The TransactionCallable is run in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and returns the transactional's outcome in a new CompletionStage that is asynchronously completed by a task run by a given Executor.

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

transactionAsync
```
CompletionStage<Void> transactionAsync(Executor executor,
                                       TransactionalRunnable transactional)
                                throws ConfigurationException
```
Run a TransactionalRunnable asynchronously.
The TransactionRunnable is run in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and returns the transactional's outcome in a new CompletionStage that is asynchronously completed by a task run by a given Executor.

Parameters:

transactional - The transactional code

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

connectionResult
```
<T> T connectionResult(ConnectionCallable<T> callable)
```
Run a ConnectionCallable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.connectionProvider().

Parameters:

callable - The code running statements against the connection.

Returns:

The outcome of the callable

connection
```
void connection(ConnectionRunnable runnable)
```
Run a ConnectionRunnable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.connectionProvider().

Parameters:

runnable - The code running statements against the connection.

mockResult
```
<T> T mockResult(MockDataProvider provider,
                 MockCallable<T> mockable)
```
Run a MockRunnable in the context of this DSLContext 's underlying Scope.configuration()'s, and of a MockDataProvider and return the mockable's outcome.

mock
```
void mock(MockDataProvider provider,
          MockRunnable mockable)
```
Run a MockRunnable in the context of this DSLContext 's underlying Scope.configuration()'s, and of a MockDataProvider.

renderContext
```
@Deprecated
@Internal
RenderContext renderContext()
```
Deprecated.
- [#6280] - 3.10 - Do not reuse this method. It will be completely internal with jOOQ 4.0
Get a new RenderContext for the context of this DSLContext.
This will return an initialised render context as such:
- RenderContext.castMode() == DEFAULT
- Context.declareFields() == false
- Context.declareTables() == false
- RenderContext.format() == false
- RenderContext.paramType() == ParamType.INDEXED
- RenderContext.qualify() == true
- Context.subquery() == false

render
```
String render(QueryPart part)
```
Render a QueryPart in the context of this DSLContext.
This is the same as calling renderContext().render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderNamedParams
```
String renderNamedParams(QueryPart part)
```
Render a QueryPart in the context of this DSLContext, rendering bind variables as named parameters.
This is the same as calling renderContext().paramType(NAMED).render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderNamedOrInlinedParams
```
String renderNamedOrInlinedParams(QueryPart part)
```
Render a QueryPart in the context of this DSLContext, rendering bind variables as named parameters, or inlined parameters if they have no name.
This is the same as calling renderContext().paramType(NAMED_OR_INLINED).render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderInlined
```
String renderInlined(QueryPart part)
```
Render a QueryPart in the context of this DSLContext, inlining all bind variables.
This is the same as calling renderContext().inline(true).render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

extractBindValues
```
List<Object> extractBindValues(QueryPart part)
```
Retrieve the bind values that will be bound by a given QueryPart.
The returned List is immutable. To modify bind values, use extractParams(QueryPart) instead.
Unlike extractParams(QueryPart), which returns also inlined parameters, this returns only actual bind values that will render an actual bind value as a question mark "?"

extractParams
```
Map<String,Param<?>> extractParams(QueryPart part)
```
Get a Map of named parameters.
The Map itself is immutable, but the Param elements allow for modifying bind values on an existing Query (or any other QueryPart).
Bind values created with DSL.val(Object) will have their bind index as name.

See Also:

Param, DSL.param(String, Object)

extractParam
```
Param<?> extractParam(QueryPart part,
                      String name)
```
Get a named parameter from a QueryPart, provided its name.
Bind values created with DSL.val(Object) will have their bind index as name.

See Also:

Param, DSL.param(String, Object)

bindContext
```
@Deprecated
@Internal
BindContext bindContext(PreparedStatement stmt)
```
Deprecated.
- [#6280] - 3.10 - Do not reuse this method. It will be completely internal with jOOQ 4.0
Get a new BindContext for the context of this DSLContext.
This will return an initialised bind context as such:
- Context.declareFields() == false
- Context.declareTables() == false
BindContext for JOOQ INTERNAL USE only. Avoid referencing it directly

bind
```
@Deprecated
int bind(QueryPart part,
         PreparedStatement stmt)
```
Deprecated.
- [#2662] - 3.2.0 - Do not reuse this method. It will be removed with jOOQ 4.0

attach
```
void attach(Attachable... attachables)
```
Attach this DSLContext's underlying Scope.configuration() to some attachables.

attach
```
void attach(Collection<? extends Attachable> attachables)
```
Attach this DSLContext's underlying Scope.configuration() to some attachables.

loadInto

@Support
<R extends Record> LoaderOptionsStep<R> loadInto(Table<R> table)

Create a new Loader object to load data from a CSV or XML source.

queries
```
@Support
Queries queries(Query... queries)
```
Wrap a collection of queries.

See Also:

DSL.queries(Query...)

queries

@Support
Queries queries(Collection<? extends Query> queries)

Wrap a collection of queries.

See Also:: DSL.queries(Collection)

begin

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
Block begin(Statement... statements)

Wrap a collection of statements in an anonymous procedural block.

See Also:: DSL.begin(Statement...)

begin

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
Block begin(Collection<? extends Statement> statements)

Wrap a collection of statements in an anoymous procedural block.

See Also:: DSL.begin(Collection)

statements
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
@Pro
Block statements(Statement... statements)
```
Wrap a collection of statements in an anonymous procedural block that does not wrap in BEGIN .. END;, unless explicitly needed.

See Also:

DSL.statements(Statement...)

statements

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,TERADATA})
@Pro
Block statements(Collection<? extends Statement> statements)

Wrap a collection of statements in an anonymous procedural block that does not wrap in BEGIN .. END;, unless explicitly needed.

See Also:: DSL.statements(Collection)

query
```
@Support
@PlainSQL
RowCountQuery query(SQL sql)
```
Create a new query holding plain SQL. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "SET SCHEMA 'abc'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query
```
@Support
@PlainSQL
RowCountQuery query(String sql)
```
Create a new query holding plain SQL. There must not be any binding variables contained in the SQL.
Example:
```
 String sql = "SET SCHEMA 'abc'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query
```
@Support
@PlainSQL
RowCountQuery query(String sql,
                    Object... bindings)
```
Create a new query holding plain SQL. There must be as many bind variables contained in the SQL, as passed in the bindings parameter.
Example:
```
 String sql = "SET SCHEMA 'abc'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

A query wrapping the plain SQL

See Also:

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

query
```
@Support
@PlainSQL
RowCountQuery query(String sql,
                    QueryPart... parts)
```
Create a new query holding plain SQL.
Unlike query(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 query("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will render this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A query wrapping the plain SQL

See Also:

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

fetch
```
@Support
@PlainSQL
Result<Record> fetch(SQL sql)
              throws DataAccessException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetch
```
@Support
@PlainSQL
Result<Record> fetch(String sql)
              throws DataAccessException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetch
```
@Support
@PlainSQL
Result<Record> fetch(String sql,
                     Object... bindings)
              throws DataAccessException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetch
```
@Support
@PlainSQL
Result<Record> fetch(String sql,
                     QueryPart... parts)
              throws DataAccessException
```
Execute a new query holding plain SQL.
Unlike fetch(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetch("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchLazy
```
@Support
@PlainSQL
Cursor<Record> fetchLazy(SQL sql)
                  throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchLazy
```
@Support
@PlainSQL
Cursor<Record> fetchLazy(String sql)
                  throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchLazy
```
@Support
@PlainSQL
Cursor<Record> fetchLazy(String sql,
                         Object... bindings)
                  throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchLazy
```
@Support
@PlainSQL
Cursor<Record> fetchLazy(String sql,
                         QueryPart... parts)
                  throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Unlike fetchLazy(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(SQL sql)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The completion stage. The completed result will never be null.

See Also:

SQL

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(String sql)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The completion stage. The completed result will never be null.

See Also:

SQL

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(String sql,
                                           Object... bindings)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The completion stage. The completed result will never be null.

See Also:

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

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(String sql,
                                           QueryPart... parts)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
Unlike fetchLazy(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The completion stage. The completed result will never be null.

See Also:

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

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           SQL sql)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The completion stage. The completed result will never be null.

See Also:

SQL

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           String sql)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The completion stage. The completed result will never be null.

See Also:

SQL

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           String sql,
                                           Object... bindings)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The completion stage. The completed result will never be null.

See Also:

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

fetchAsync
```
@Support
@PlainSQL
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           String sql,
                                           QueryPart... parts)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
Unlike fetchLazy(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The completion stage. The completed result will never be null.

See Also:

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

fetchStream
```
@Support
@PlainSQL
Stream<Record> fetchStream(SQL sql)
                    throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results from the executed query. This is never null, even if the database returns no ResultSet

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchStream
```
@Support
@PlainSQL
Stream<Record> fetchStream(String sql)
                    throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results from the executed query. This is never null, even if the database returns no ResultSet

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchStream
```
@Support
@PlainSQL
Stream<Record> fetchStream(String sql,
                           Object... bindings)
                    throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query. This is never null, even if the database returns no ResultSet

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchStream
```
@Support
@PlainSQL
Stream<Record> fetchStream(String sql,
                           QueryPart... parts)
                    throws DataAccessException
```
Execute a new query holding plain SQL and "lazily" return the generated result.
The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.
Unlike fetchStream(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The results from the executed query. This is never null, even if the database returns no ResultSet

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchMany
```
@Support
@PlainSQL
Results fetchMany(SQL sql)
           throws DataAccessException
```
Execute a new query holding plain SQL, possibly returning several result sets.
Example (Sybase ASE):
```
 String sql = "sp_help 'my_table'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchMany
```
@Support
@PlainSQL
Results fetchMany(String sql)
           throws DataAccessException
```
Execute a new query holding plain SQL, possibly returning several result sets.
Example (Sybase ASE):
```
 String sql = "sp_help 'my_table'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchMany
```
@Support
@PlainSQL
Results fetchMany(String sql,
                  Object... bindings)
           throws DataAccessException
```
Execute a new query holding plain SQL, possibly returning several result sets.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Sybase ASE):
```
 String sql = "sp_help 'my_table'";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchMany
```
@Support
@PlainSQL
Results fetchMany(String sql,
                  QueryPart... parts)
           throws DataAccessException
```
Execute a new query holding plain SQL, possibly returning several result sets.
Unlike fetchMany(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchMany("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchOne
```
@Support
@PlainSQL
Record fetchOne(SQL sql)
         throws DataAccessException,
                TooManyRowsException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOne
```
@Support
@PlainSQL
Record fetchOne(String sql)
         throws DataAccessException,
                TooManyRowsException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOne
```
@Support
@PlainSQL
Record fetchOne(String sql,
                Object... bindings)
         throws DataAccessException,
                TooManyRowsException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchOne
```
@Support
@PlainSQL
Record fetchOne(String sql,
                QueryPart... parts)
         throws DataAccessException,
                TooManyRowsException
```
Execute a new query holding plain SQL.
Unlike fetchOne(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchSingle
```
@Support
@PlainSQL
Record fetchSingle(SQL sql)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchSingle
```
@Support
@PlainSQL
Record fetchSingle(String sql)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchSingle
```
@Support
@PlainSQL
Record fetchSingle(String sql,
                   Object... bindings)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchSingle
```
@Support
@PlainSQL
Record fetchSingle(String sql,
                   QueryPart... parts)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Execute a new query holding plain SQL.
Unlike fetchOne(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchOptional
```
@Support
@PlainSQL
Optional<Record> fetchOptional(SQL sql)
                        throws DataAccessException,
                               TooManyRowsException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOptional
```
@Support
@PlainSQL
Optional<Record> fetchOptional(String sql)
                        throws DataAccessException,
                               TooManyRowsException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOptional
```
@Support
@PlainSQL
Optional<Record> fetchOptional(String sql,
                               Object... bindings)
                        throws DataAccessException,
                               TooManyRowsException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchOptional
```
@Support
@PlainSQL
Optional<Record> fetchOptional(String sql,
                               QueryPart... parts)
                        throws DataAccessException,
                               TooManyRowsException
```
Execute a new query holding plain SQL.
Unlike fetchOne(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchValue
```
@Support
@PlainSQL
Object fetchValue(SQL sql)
           throws DataAccessException,
                  TooManyRowsException,
                  InvalidResultException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

SQL

fetchValue
```
@Support
@PlainSQL
Object fetchValue(String sql)
           throws DataAccessException,
                  TooManyRowsException,
                  InvalidResultException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

SQL

fetchValue
```
@Support
@PlainSQL
Object fetchValue(String sql,
                  Object... bindings)
           throws DataAccessException,
                  TooManyRowsException,
                  InvalidResultException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

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

fetchValue
```
@Support
@PlainSQL
Object fetchValue(String sql,
                  QueryPart... parts)
           throws DataAccessException,
                  TooManyRowsException,
                  InvalidResultException
```
Execute a new query holding plain SQL.
Unlike fetchValue(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

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

fetchOptionalValue
```
@Support
@PlainSQL
Optional<?> fetchOptionalValue(SQL sql)
                        throws DataAccessException,
                               TooManyRowsException,
                               InvalidResultException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The result value from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

SQL

fetchOptionalValue
```
@Support
@PlainSQL
Optional<?> fetchOptionalValue(String sql)
                        throws DataAccessException,
                               TooManyRowsException,
                               InvalidResultException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The result value from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

SQL

fetchOptionalValue
```
@Support
@PlainSQL
Optional<?> fetchOptionalValue(String sql,
                               Object... bindings)
                        throws DataAccessException,
                               TooManyRowsException,
                               InvalidResultException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

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

fetchOptionalValue
```
@Support
@PlainSQL
Optional<?> fetchOptionalValue(String sql,
                               QueryPart... parts)
                        throws DataAccessException,
                               TooManyRowsException,
                               InvalidResultException
```
Execute a new query holding plain SQL.
Unlike fetchValue(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

See Also:

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

fetchValues
```
@Support
@PlainSQL
List<?> fetchValues(SQL sql)
             throws DataAccessException,
                    InvalidResultException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

See Also:

SQL

fetchValues
```
@Support
@PlainSQL
List<?> fetchValues(String sql)
             throws DataAccessException,
                    InvalidResultException
```
Execute a new query holding plain SQL.
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

See Also:

SQL

fetchValues
```
@Support
@PlainSQL
List<?> fetchValues(String sql,
                    Object... bindings)
             throws DataAccessException,
                    InvalidResultException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
```
 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";
```
Example (SQLite):
```
 String sql = "pragma table_info('my_table')";
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
Parameters:

sql - The SQL

bindings - The bindings

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

See Also:

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

fetchValues
```
@Support
@PlainSQL
List<?> fetchValues(String sql,
                    QueryPart... parts)
             throws DataAccessException,
                    InvalidResultException
```
Execute a new query holding plain SQL.
Unlike fetchValue(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

See Also:

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

execute
```
@Support
@PlainSQL
int execute(SQL sql)
     throws DataAccessException
```
Execute a query holding plain SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

execute
```
@Support
@PlainSQL
int execute(String sql)
     throws DataAccessException
```
Execute a query holding plain SQL.
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

execute
```
@Support
@PlainSQL
int execute(String sql,
            Object... bindings)
     throws DataAccessException
```
Execute a new query holding plain SQL.
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

execute
```
@Support
@PlainSQL
int execute(String sql,
            QueryPart... parts)
     throws DataAccessException
```
Execute a new query holding plain SQL.
Unlike execute(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 execute("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

resultQuery

@Support
@PlainSQL
ResultQuery<Record> resultQuery(SQL sql)

Create a new query holding plain SQL.

There must not be any bind variables contained in the SQL

Use this method, when you want to take advantage of the many ways to fetch results in jOOQ, using ResultQuery. Some examples:

`ResultQuery.fetchLazy()`	Open a cursor and fetch records one by one
`ResultQuery.fetchInto(Class)`	Fetch records into a custom POJO (optionally annotated with JPA annotations)
`ResultQuery.fetchInto(RecordHandler)`	Fetch records into a custom callback (similar to Spring's RowMapper)

Example (Postgres):

 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";

Example (SQLite):

 String sql = "pragma table_info('my_table')";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:: sql - The SQL
Returns:: An executable query
See Also:: SQL

resultQuery

@Support
@PlainSQL
ResultQuery<Record> resultQuery(String sql)

Create a new query holding plain SQL.

There must not be any bind variables contained in the SQL

Use this method, when you want to take advantage of the many ways to fetch results in jOOQ, using ResultQuery. Some examples:

`ResultQuery.fetchLazy()`	Open a cursor and fetch records one by one
`ResultQuery.fetchInto(Class)`	Fetch records into a custom POJO (optionally annotated with JPA annotations)
`ResultQuery.fetchInto(RecordHandler)`	Fetch records into a custom callback (similar to Spring's RowMapper)

Example (Postgres):

 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";

Example (SQLite):

 String sql = "pragma table_info('my_table')";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:: sql - The SQL
Returns:: An executable query
See Also:: SQL

resultQuery

@Support
@PlainSQL
ResultQuery<Record> resultQuery(String sql,
                                Object... bindings)

Create a new query holding plain SQL.

There must be as many bind variables contained in the SQL, as passed in the bindings parameter

Use this method, when you want to take advantage of the many ways to fetch results in jOOQ, using ResultQuery. Some examples:

`ResultQuery.fetchLazy()`	Open a cursor and fetch records one by one
`ResultQuery.fetchInto(Class)`	Fetch records into a custom POJO (optionally annotated with JPA annotations)
`ResultQuery.fetchInto(RecordHandler)`	Fetch records into a custom callback (similar to Spring's RowMapper)

Example (Postgres):

 String sql = "FETCH ALL IN \"<unnamed cursor 1>\"";

Example (SQLite):

 String sql = "pragma table_info('my_table')";

NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!

Parameters:: sql - The SQL; bindings - The bindings
Returns:: A query wrapping the plain SQL
See Also:: SQL, DSL.sql(String, Object...)

resultQuery
```
@Support
@PlainSQL
ResultQuery<Record> resultQuery(String sql,
                                QueryPart... parts)
```
Create a new query holding plain SQL.
Unlike resultQuery(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:
```
 // The following query
 resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will render this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses! One way to escape literals is to use DSL.name(String...) and similar methods
Parameters:

sql - The SQL clause, containing {numbered placeholders} where query parts can be injected

parts - The QueryPart objects that are rendered at the {numbered placeholder} locations

Returns:

A query wrapping the plain SQL

See Also:

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

fetch
```
@Support
Result<Record> fetch(ResultSet rs)
              throws DataAccessException
```
Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
After fetching all data, the JDBC ResultSet will be closed.
Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch
```
@Support
Result<Record> fetch(ResultSet rs,
                     Field<?>... fields)
              throws DataAccessException
```
Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
After fetching all data, the JDBC ResultSet will be closed.
Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch
```
@Support
Result<Record> fetch(ResultSet rs,
                     DataType<?>... types)
              throws DataAccessException
```
Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
After fetching all data, the JDBC ResultSet will be closed.
Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch
```
@Support
Result<Record> fetch(ResultSet rs,
                     Class<?>... types)
              throws DataAccessException
```
Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
After fetching all data, the JDBC ResultSet will be closed.
Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchOne
```
@Support
Record fetchOne(ResultSet rs)
         throws DataAccessException,
                TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne
```
@Support
Record fetchOne(ResultSet rs,
                Field<?>... fields)
         throws DataAccessException,
                TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne
```
@Support
Record fetchOne(ResultSet rs,
                DataType<?>... types)
         throws DataAccessException,
                TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne
```
@Support
Record fetchOne(ResultSet rs,
                Class<?>... types)
         throws DataAccessException,
                TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
Record fetchSingle(ResultSet rs)
            throws DataAccessException,
                   TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
Record fetchSingle(ResultSet rs,
                   Field<?>... fields)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
Record fetchSingle(ResultSet rs,
                   DataType<?>... types)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
Record fetchSingle(ResultSet rs,
                   Class<?>... types)
            throws DataAccessException,
                   NoDataFoundException,
                   TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchOptional
```
@Support
Optional<Record> fetchOptional(ResultSet rs)
                        throws DataAccessException,
                               NoDataFoundException,
                               TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchOptional
```
@Support
Optional<Record> fetchOptional(ResultSet rs,
                               Field<?>... fields)
                        throws DataAccessException,
                               TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional
```
@Support
Optional<Record> fetchOptional(ResultSet rs,
                               DataType<?>... types)
                        throws DataAccessException,
                               TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional
```
@Support
Optional<Record> fetchOptional(ResultSet rs,
                               Class<?>... types)
                        throws DataAccessException,
                               TooManyRowsException
```
Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue
```
@Support
Object fetchValue(ResultSet rs)
           throws DataAccessException,
                  TooManyRowsException,
                  InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchValue
```
@Support
<T> T fetchValue(ResultSet rs,
                 Field<T> field)
          throws DataAccessException,
                 TooManyRowsException,
                 InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional field argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchValue
```
@Support
<T> T fetchValue(ResultSet rs,
                 DataType<T> type)
          throws DataAccessException,
                 TooManyRowsException,
                 InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchValue
```
@Support
<T> T fetchValue(ResultSet rs,
                 Class<T> type)
          throws DataAccessException,
                 TooManyRowsException,
                 InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchOptionalValue
```
@Support
Optional<?> fetchOptionalValue(ResultSet rs)
                        throws DataAccessException,
                               TooManyRowsException,
                               InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchOptionalValue
```
@Support
<T> Optional<T> fetchOptionalValue(ResultSet rs,
                                   Field<T> field)
                            throws DataAccessException,
                                   TooManyRowsException,
                                   InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional field argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchOptionalValue
```
@Support
<T> Optional<T> fetchOptionalValue(ResultSet rs,
                                   DataType<T> type)
                            throws DataAccessException,
                                   TooManyRowsException,
                                   InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchOptionalValue
```
@Support
<T> Optional<T> fetchOptionalValue(ResultSet rs,
                                   Class<T> type)
                            throws DataAccessException,
                                   TooManyRowsException,
                                   InvalidResultException
```
Fetch a record from a JDBC ResultSet and return the only contained value.
This will internally fetch all records and throw an exception if there was more than one resulting record.
The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchValues
```
@Support
List<?> fetchValues(ResultSet rs)
             throws DataAccessException,
                    InvalidResultException
```
Fetch a result from a JDBC ResultSet and return the only contained column's values.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

fetchValues
```
@Support
<T> List<T> fetchValues(ResultSet rs,
                        Field<T> field)
                 throws DataAccessException,
                        InvalidResultException
```
Fetch a result from a JDBC ResultSet and return the only contained column's values.
The additional field argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

fetchValues
```
@Support
<T> List<T> fetchValues(ResultSet rs,
                        DataType<T> type)
                 throws DataAccessException,
                        InvalidResultException
```
Fetch a result from a JDBC ResultSet and return the only contained column's values.
The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

fetchValues
```
@Support
<T> List<T> fetchValues(ResultSet rs,
                        Class<T> type)
                 throws DataAccessException,
                        InvalidResultException
```
Fetch a result from a JDBC ResultSet and return the only contained column's values.
The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned a record with more than one value

fetchLazy
```
@Support
Cursor<Record> fetchLazy(ResultSet rs)
                  throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Cursor.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
Cursor<Record> fetchLazy(ResultSet rs,
                         Field<?>... fields)
                  throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Cursor.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
Cursor<Record> fetchLazy(ResultSet rs,
                         DataType<?>... types)
                  throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Cursor.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
Cursor<Record> fetchLazy(ResultSet rs,
                         Class<?>... types)
                  throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Cursor.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(ResultSet rs)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(ResultSet rs,
                                           Field<?>... fields)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(ResultSet rs,
                                           DataType<?>... types)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(ResultSet rs,
                                           Class<?>... types)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           ResultSet rs)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           ResultSet rs,
                                           Field<?>... fields)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           ResultSet rs,
                                           DataType<?>... types)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                           ResultSet rs,
                                           Class<?>... types)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The completion stage. The completed result will never be null.

fetchStream
```
@Support
Stream<Record> fetchStream(ResultSet rs)
                    throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Stream.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchStream
```
@Support
Stream<Record> fetchStream(ResultSet rs,
                           Field<?>... fields)
                    throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Stream.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.
The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchStream
```
@Support
Stream<Record> fetchStream(ResultSet rs,
                           DataType<?>... types)
                    throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Stream.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchStream
```
@Support
Stream<Record> fetchStream(ResultSet rs,
                           Class<?>... types)
                    throws DataAccessException
```
Wrap a JDBC ResultSet into a jOOQ Stream.
Use fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.
The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchFromTXT
```
@Support
Result<Record> fetchFromTXT(String string)
                     throws DataAccessException
```
Fetch all data from a formatted string.
The supplied string is supposed to be formatted in a human-readable way. This is the same as calling fetchFromTXT(string, "{null}")

Parameters:

string - The formatted string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If the supplied string does not adhere to the above format rules.

See Also:

fetchFromTXT(String, String)

fetchFromTXT
```
@Support
Result<Record> fetchFromTXT(String string,
                            String nullLiteral)
                     throws DataAccessException
```
Fetch all data from a formatted string.
This method supports parsing results from two types of human-readable formats:
The jOOQ Formattable.format()

This format is recognised by the fact that the first line starts with a "plus" sign:
```
 +-----+-----+--------------------------+
 |COL1 |COL2 |COL3 containing whitespace|
 +-----+-----+--------------------------+
 |val1 |1    |some text                 |
 |val2 | 2   | more text                |
 +-----+-----+--------------------------+
 
```
This method will decode the above formatted string according to the following rules:
- The number of columns is defined by the number of dash groups in the first line. Groups are separated by exactly one "plus" sign
- The column types are VARCHAR(N) where N = number of dashes per dash group
- The column names are defined by the trimmed text contained in the second row
- The data is defined by the trimmed text contained in the subsequent rows
The H2 database test data format

The supplied string is supposed to be formatted in the following, human-readable way:
```
 COL1  COL2   COL3 containing whitespace
 ----- ----   --------------------------
 val1  1      some text
 val2   2      more text
 
```
This method will decode the above formatted string according to the following rules:
- The number of columns is defined by the number of dash groups in the second line. Groups are separated by space(s)
- The column types are VARCHAR(N) where N = number of dashes per dash group
- The column names are defined by the trimmed text contained in the first row
- The data is defined by the trimmed text contained in the subsequent rows
Both parsing methods

Both parsing methods make no assumption about the resulting data types. Instead, all data is string-based.
Parameters:

string - The formatted string

nullLiteral - The string literal to be used as null value.

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If the supplied string does not adhere to the above format rules.

fetchFromHTML
```
@Support
Result<Record> fetchFromHTML(String string)
                      throws DataAccessException
```
Convert an HTML table into a jOOQ Result.
This is the inverse operation of Formattable.formatHTML(). It works according to the following parsing rules:
- The input is expected to be well-formed XML. XHTML conformance is not required - i.e. unknown elements / attributes, or elements / attributes not specified here, such as <caption>, <thead>, <tbody> are simply ignored.
- The surrounding <table> element is optional, but it may appear only once
- A single row containing table headings <th> is allowed. Further rows containing table headings are ignored. Table headings define field names. In the absence of table headings, field names are generated.
- The first row <tr> specifies the number of columns in the table (regardless if it contains table headings or not). Subsequent rows containing less columns will be padded. Subsequent rows containing more columns will be truncated.
- Comments are ignored
- Nested tables are not supported
Ideal input looks like this:
```
 <table>
 <tr><th>COL1</th><th>COL2</th></tr>
 <tr><td>1</td><td>a</td></tr>
 <tr><td>2</td><td>b</td></tr>
 </table>
 
 
```
Parameters:

string - The HTML-formatted string.

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If the supplied string does not adhere to the above format rules.

fetchFromCSV
```
@Support
Result<Record> fetchFromCSV(String string)
                     throws DataAccessException
```
Fetch all data from a CSV string.
This is the same as calling fetchFromCSV(string, ',') and the inverse of calling Formattable.formatCSV(). The first row of the CSV data is required to hold field name information. Subsequent rows may contain data, which is interpreted as String. Use the various conversion methods to retrieve other data types from the Result:
Missing values result in null. Empty values result in empty Strings
Parameters:

string - The CSV string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String, char)

fetchFromCSV
```
@Support
Result<Record> fetchFromCSV(String string,
                            char delimiter)
                     throws DataAccessException
```
Fetch all data from a CSV string.
This is inverse of calling Formattable.formatCSV(char). The first row of the CSV data is required to hold field name information. Subsequent rows may contain data, which is interpreted as String. Use the various conversion methods to retrieve other data types from the Result:
Missing values result in null. Empty values result in empty Strings
Parameters:

string - The CSV string

delimiter - The delimiter to expect between records

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String), fetchFromStringData(List)

fetchFromCSV
```
@Support
Result<Record> fetchFromCSV(String string,
                            boolean header)
                     throws DataAccessException
```
Fetch all data from a CSV string.
This is the same as calling fetchFromCSV(string, ',') and the inverse of calling Formattable.formatCSV(boolean). Rows may contain data, which is interpreted as String. Use the various conversion methods to retrieve other data types from the Result:
Missing values result in null. Empty values result in empty Strings
Parameters:

string - The CSV string

header - Whether to parse the first line as a CSV header line

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String, char)

fetchFromCSV
```
@Support
Result<Record> fetchFromCSV(String string,
                            boolean header,
                            char delimiter)
                     throws DataAccessException
```
Fetch all data from a CSV string.
This is inverse of calling Formattable.formatCSV(boolean, char). Rows may contain data, which are interpreted as String. Use the various conversion methods to retrieve other data types from the Result:
Missing values result in null. Empty values result in empty Strings
Parameters:

string - The CSV string

header - Whether to parse the first line as a CSV header line

delimiter - The delimiter to expect between records

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String), fetchFromStringData(List)

fetchFromJSON
```
@Support
Result<Record> fetchFromJSON(String string)
```
Fetch all data from a JSON string.
This is the inverse of calling Formattable.formatJSON(). Use the various conversion methods to retrieve other data types from the Result:
Missing values result in null. Empty values result in empty Strings
Parameters:

string - The JSON string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the JSON file

fetchFromXML
```
@Support
Result<Record> fetchFromXML(String string)
```
Fetch all data from an XML string.
This is the inverse of calling Formattable.formatXML(). Use the various conversion methods to retrieve other data types from the Result:
Missing values result in null. Empty values result in empty Strings
Parameters:

string - The XML string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the XML file

fetchFromStringData
```
Result<Record> fetchFromStringData(String[]... data)
```
Fetch all data from a list of strings.
This is used by methods such as
- fetchFromCSV(String)
- fetchFromTXT(String)
The first element of the argument list should contain column names. Subsequent elements contain actual data. The degree of all arrays contained in the argument should be the same, although this is not a requirement. jOOQ will ignore excess data, and fill missing data with null.
Parameters:

data - The data to be transformed into a Result

Returns:

The transformed result. This will never be null.

See Also:

fetchFromStringData(List)

fetchFromStringData
```
Result<Record> fetchFromStringData(List<String[]> data)
```
Fetch all data from a list of strings.
This is used by methods such as
- fetchFromCSV(String)
- fetchFromTXT(String)
The first element of the argument list should contain column names. Subsequent elements contain actual data. The degree of all arrays contained in the argument should be the same, although this is not a requirement. jOOQ will ignore excess data, and fill missing data with null.
Parameters:

data - The data to be transformed into a Result

Returns:

The transformed result. This will never be null.

fetchFromStringData
```
Result<Record> fetchFromStringData(List<String[]> data,
                                   boolean header)
```
Fetch all data from a list of strings.
This is used by methods such as
- fetchFromCSV(String)
- fetchFromTXT(String)
The degree of all arrays contained in the argument should be the same, although this is not a requirement. jOOQ will ignore excess data, and fill missing data with null.
Parameters:

data - The data to be transformed into a Result

header - Whether to interpret the first line as a set of column names.

Returns:

The transformed result. This will never be null.

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

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

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

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

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

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

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

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

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

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

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

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
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.

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
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.

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

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

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

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

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive
```
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
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.

selectFrom
```
@Support
<R extends Record> SelectWhereStep<R> selectFrom(Table<R> table)
```
Create a new DSL select statement, projecting the known columns from a table.
This will project the known columns from the argument table querying TableLike.fields(). If no known columns are available (e.g. because the table has been created using DSL.table(String)), then SELECT * is projected.
Example:
```
 SELECT table.col1, table.col2 FROM table
 
```

selectFrom
```
@Support
<R extends Record> SelectWhereStep<R> selectFrom(Name table)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Example:
```
 SELECT * FROM table
 
```
See Also:

DSL.table(Name)

selectFrom
```
@Support
@PlainSQL
<R extends Record> SelectWhereStep<R> selectFrom(SQL sql)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

DSL.table(SQL), SQL

selectFrom
```
@Support
@PlainSQL
<R extends Record> SelectWhereStep<R> selectFrom(String sql)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

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

selectFrom
```
@Support
@PlainSQL
<R extends Record> SelectWhereStep<R> selectFrom(String sql,
                                                 Object... bindings)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

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

selectFrom
```
@Support
@PlainSQL
<R extends Record> SelectWhereStep<R> selectFrom(String sql,
                                                 QueryPart... parts)
```
Create a new DSL select statement, projecting *.
Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.
Example:
```
 SELECT * FROM table
 
```
NOTE: When inserting plain SQL into jOOQ objects, you must guarantee syntax integrity. You may also create the possibility of malicious SQL injection. Be sure to properly use bind variables and/or escape literals when concatenated into SQL clauses!
See Also:

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

select
```
@Support
SelectSelectStep<Record> select(Collection<? extends SelectFieldOrAsterisk> fields)
```
Create a new DSL select statement.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(Collection) instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.select(Collection)

select
```
@Support
SelectSelectStep<Record> select(SelectFieldOrAsterisk... fields)
```
Create a new DSL select statement.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectFieldOrAsterisk...) instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.select(SelectFieldOrAsterisk...)

select
```
@Support
<T1> SelectSelectStep<Record1<T1>> select(SelectField<T1> field1)
```
Create a new DSL select statement.
This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Field.in(Select), Field.equal(Select) and other predicate building methods taking subselect arguments.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField) instead.
Example:
```
 using(configuration)
       .select(field1)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 
```
See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

select
```
@Support
<T1,T2> SelectSelectStep<Record2<T1,T2>> select(SelectField<T1> field1,
                                                            SelectField<T2> field2)
```
Create a new DSL select statement.
This is the same as select(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row2.in(Select), Row2.equal(Select) and other predicate building methods taking subselect arguments.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField) instead.
Example:
```
 using(configuration)
       .select(field1, field2)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 
```
See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.select(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

select

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

Create a new DSL select statement.

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

Example:

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

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

select

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

Create a new DSL select statement.

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

Example:

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

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

select

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

Create a new DSL select statement.

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

Example:

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

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

selectDistinct
```
@Support
SelectSelectStep<Record> selectDistinct(Collection<? extends SelectFieldOrAsterisk> fields)
```
Create a new DSL select statement.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(Collection) instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.selectDistinct(Collection)

selectDistinct
```
@Support
SelectSelectStep<Record> selectDistinct(SelectFieldOrAsterisk... fields)
```
Create a new DSL select statement.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectFieldOrAsterisk...) instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.selectDistinct(SelectFieldOrAsterisk...)

selectDistinct
```
@Support
<T1> SelectSelectStep<Record1<T1>> selectDistinct(SelectField<T1> field1)
```
Create a new DSL select statement.
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Field.in(Select), Field.equal(Select) and other predicate building methods taking subselect arguments.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField) instead.
Example:
```
 using(configuration)
       .selectDistinct(field1)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 
```
See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct
```
@Support
<T1,T2> SelectSelectStep<Record2<T1,T2>> selectDistinct(SelectField<T1> field1,
                                                                    SelectField<T2> field2)
```
Create a new DSL select statement.
This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row2.in(Select), Row2.equal(Select) and other predicate building methods taking subselect arguments.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField) instead.
Example:
```
 using(configuration)
       .selectDistinct(field1, field2)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 
```
See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

Example:

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

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

selectDistinct

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

Create a new DSL select statement.

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

Example:

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

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

selectZero
```
@Support
SelectSelectStep<Record1<Integer>> selectZero()
```
Create a new DSL select statement for a constant 0 literal.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectZero() instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.zero(), DSL.selectZero()

selectOne
```
@Support
SelectSelectStep<Record1<Integer>> selectOne()
```
Create a new DSL select statement for a constant 1 literal.
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectOne() instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.one(), DSL.selectOne()

selectCount
```
@Support
SelectSelectStep<Record1<Integer>> selectCount()
```
Create a new DSL select statement for COUNT(*).
This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectCount() instead.
Example:
```
 DSLContext create = DSL.using(configuration);

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

DSL.selectCount()

selectQuery

@Support
SelectQuery<Record> selectQuery()

Create a new SelectQuery

selectQuery
```
@Support
<R extends Record> SelectQuery<R> selectQuery(TableLike<R> table)
```
Create a new SelectQuery

Parameters:

table - The table to select data from

Returns:

The new SelectQuery

insertQuery
```
@Support
<R extends Record> InsertQuery<R> insertQuery(Table<R> into)
```
Create a new InsertQuery

Parameters:

into - The table to insert data into

Returns:

The new InsertQuery

insertInto

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

Create a new DSL 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:

 DSLContext create = DSL.using(configuration);

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

insertInto

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

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1)
       .values(field1)
       .values(field1)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();

insertInto

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

Example:

 using(configuration)
       .insertInto(table, field1, field2)
       .values(field1, field2)
       .values(field1, field2)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();

insertInto

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

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3)
       .values(field1, field2, field3)
       .values(field1, field2, field3)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();

insertInto

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

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, field4)
       .values(field1, field2, field3, field4)
       .values(field1, field2, field3, field4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

 using(configuration)
       .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)
       .execute();

insertInto

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

Example:

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

insertInto

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

Example:

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

insertInto

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

Example:

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

insertInto

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

Example:

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

insertInto

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

Example:

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

insertInto

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

Create a new DSL insert statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.insertInto(table, field1, field2)
       .values(value1, value2)
       .values(value3, value4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();

insertInto

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

Create a new DSL insert statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.insertInto(table, field1, field2)
       .values(value1, value2)
       .values(value3, value4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();

updateQuery
```
@Support
<R extends Record> UpdateQuery<R> updateQuery(Table<R> table)
```
Create a new UpdateQuery

Parameters:

table - The table to update data into

Returns:

The new UpdateQuery

update

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

Create a new DSL update statement.

Example:

 DSLContext create = DSL.using(configuration);

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

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

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

mergeInto

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

Create a new DSL SQL standard MERGE statement.

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

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

Example:

 DSLContext create = DSL.using(configuration);

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

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

mergeInto

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

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

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

mergeInto

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

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

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

mergeInto

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

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

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

mergeInto

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

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

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

mergeInto

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

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

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

mergeInto

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

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

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

mergeInto

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

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> mergeInto(Table<R> table,
                                                                                                                                                                                              Field<T1> field1,
                                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                                              Field<T8> field8)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> mergeInto(Table<R> table,
                                                                                                                                                                                                                Field<T1> field1,
                                                                                                                                                                                                                Field<T2> field2,
                                                                                                                                                                                                                Field<T3> field3,
                                                                                                                                                                                                                Field<T4> field4,
                                                                                                                                                                                                                Field<T5> field5,
                                                                                                                                                                                                                Field<T6> field6,
                                                                                                                                                                                                                Field<T7> field7,
                                                                                                                                                                                                                Field<T8> field8,
                                                                                                                                                                                                                Field<T9> field9)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> mergeInto(Table<R> table,
                                                                                                                                                                                                                                     Field<T1> field1,
                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                     Field<T10> field10)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                         Field<T1> field1,
                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                         Field<T11> field11)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                             Field<T1> field1,
                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                             Field<T12> field12)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                 Field<T1> field1,
                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                 Field<T13> field13)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                     Field<T1> field1,
                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                     Field<T14> field14)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                         Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                         Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                         Field<T15> field15)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                             Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                             Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                             Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                             Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                             Field<T16> field16)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T17> field17)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T18> field18)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T19> field19)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T20> field20)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T21> field21)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T22> field22)

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

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

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table,
                                              Field<?>... fields)

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

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

H2	H2 natively supports this special syntax	http://www.h2database.com/html/grammar.html#merge
HANA	HANA natively supports this syntax	http://help.sap.com/saphelp_hanaplatform/helpdata/en/20/fc06a7751910149892c0d09be21a38/content.htm
PostgreSQL	This database can emulate the H2-specific MERGE statement via `INSERT .. ON CONFLICT DO UPDATE`	http://www.postgresql.org/docs/9.5/static/sql-insert.html
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere	These databases can emulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions	See `mergeInto(Table)` for the standard MERGE statement

mergeInto

@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table,
                                              Collection<? extends Field<?>> fields)

Create a new DSL merge statement (H2-specific syntax).

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

deleteQuery
```
@Support
<R extends Record> DeleteQuery<R> deleteQuery(Table<R> table)
```
Create a new DeleteQuery

Parameters:

table - The table to delete data from

Returns:

The new DeleteQuery

deleteFrom

@Support
<R extends Record> DeleteWhereStep<R> deleteFrom(Table<R> table)

Create a new DSL delete statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.deleteFrom(table)
       .where(field1.greaterThan(100))
       .execute();

Some but not all databases support aliased tables in delete statements.

delete

@Support
<R extends Record> DeleteWhereStep<R> delete(Table<R> table)

Create a new DSL delete statement.

This is an alias for deleteFrom(Table)

batch

@Support
Batch batch(Query... queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This essentially runs the following logic:

 Statement s = connection.createStatement();

 for (Query query : queries) {
     s.addBatch(query.getSQL(true));
 }

 s.execute();

See Also:: Statement.executeBatch()

batch

@Support
Batch batch(Queries queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This essentially runs the following logic:

 Statement s = connection.createStatement();

 for (Query query : queries) {
     s.addBatch(query.getSQL(true));
 }

 s.execute();

See Also:: Statement.executeBatch()

batch
```
@Support
Batch batch(String... queries)
```
Create a batch statement to execute a set of queries in batch mode (without bind values).
This is a convenience method for calling
```
batch(query(queries[0]), query(queries[1]), ...)
```
.
See Also:

query(String), batch(Query...), Statement.executeBatch()

batch

@Support
Batch batch(Collection<? extends Query> queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This essentially runs the following logic:

 Statement s = connection.createStatement();

 for (Query query : queries) {
     s.addBatch(query.getSQL(true));
 }

 s.execute();

See Also:: Statement.executeBatch()

batch

@Support
BatchBindStep batch(Query query)

Create a batch statement to execute a set of queries in batch mode (with bind values).

When running

 create.batch(query)
       .bind(valueA1, valueA2)
       .bind(valueB1, valueB2)
       .execute();

This essentially runs the following logic:

 Statement s = connection.prepareStatement(query.getSQL(false));

 for (Object[] bindValues : allBindValues) {
     for (Object bindValue : bindValues) {
         s.setXXX(bindValue);
     }

     s.addBatch();
 }

 s.execute();

Note: bind values will be inlined to a static batch query as in batch(Query...), if you choose to execute queries with Settings.getStatementType() == StatementType.STATIC_STATEMENT

See Also:: Statement.executeBatch()

batch
```
@Support
BatchBindStep batch(String sql)
```
Create a batch statement to execute a set of queries in batch mode (with bind values).
This is a convenience method for calling
```
batch(query(sql))
```
.
See Also:

query(String), batch(Query), Statement.executeBatch()

batch
```
@Support
Batch batch(Query query,
            Object[]... bindings)
```
Create a batch statement to execute a set of queries in batch mode (with bind values).
This is a convenience method for calling batch(Query) and then binding values one by one using BatchBindStep.bind(Object...)
Note: bind values will be inlined to a static batch query as in batch(Query...), if you choose to execute queries with Settings.getStatementType() == StatementType.STATIC_STATEMENT

See Also:

batch(Query), Statement.executeBatch()

batch
```
@Support
Batch batch(String sql,
            Object[]... bindings)
```
Create a batch statement to execute a set of queries in batch mode (with bind values).
This is a convenience method for calling
```
batch(query(sql), bindings)
```
.
See Also:

query(String), batch(Query, Object[][]), Statement.executeBatch()

batchStore
```
@Support
Batch batchStore(UpdatableRecord<?>... records)
```
Create a batch statement to execute a set of INSERT and UPDATE queries in batch mode (with bind values) according to UpdatableRecord.store() semantics.
This batch operation can be executed in two modes:

With Settings.getStatementType() == StatementType.PREPARED_STATEMENT (the default)

In this mode, record order is preserved as much as possible, as long as two subsequent records generate the same SQL (with bind variables). The number of executed batch operations corresponds to [number of distinct rendered SQL statements]. In the worst case, this corresponds to the number of total records.
The record type order is preserved in the way they are passed to this method. This is an example of how statements will be ordered:
```
 // Let's assume, odd numbers result in INSERTs and even numbers in UPDATES
 // Let's also assume a[n] are all of the same type, just as b[n], c[n]...
 int[] result = create.batchStore(a1, a2, a3, b1, a4, c1, b3, a5)
                      .execute();
 
```
The above results in result.length == 8 and the following 4 separate batch statements:
1. INSERT a1, a3, a5
2. UPDATE a2, a4
3. INSERT b1, b3
4. INSERT c1
With Settings.getStatementType() == StatementType.STATIC_STATEMENT

This mode may be better for large and complex batch store operations, as the order of records is preserved entirely, and jOOQ can guarantee that only a single batch statement is serialised to the database.

A note on MERGE / UPSERT semantics

This method (just like UpdatableRecord.store()) does not implement the semantics of an actual UPSERT or MERGE statement, which delegates the decision of whether to INSERT or UPDATE a record to the database. The decision is made by the client (jOOQ) depending on whether each individual record has been fetched from the database prior to storing it.
See Also:

UpdatableRecord.store(), Statement.executeBatch()

batchStore
```
@Support
Batch batchStore(Collection<? extends UpdatableRecord<?>> records)
```
Create a batch statement to execute a set of INSERT and UPDATE queries in batch mode (with bind values) according to UpdatableRecord.store() semantics.

See Also:

batchStore(UpdatableRecord...), UpdatableRecord.store(), Statement.executeBatch()

batchInsert
```
@Support
Batch batchInsert(TableRecord<?>... records)
```
Create a batch statement to execute a set of INSERT queries in batch mode (with bind values) according to TableRecord.insert() semantics.

See Also:

batchStore(UpdatableRecord...), TableRecord.insert(), Statement.executeBatch()

batchInsert
```
@Support
Batch batchInsert(Collection<? extends TableRecord<?>> records)
```
Create a batch statement to execute a set of INSERT queries in batch mode (with bind values) according to TableRecord.insert() semantics.

See Also:

batchStore(UpdatableRecord...), Statement.executeBatch()

batchUpdate
```
@Support
Batch batchUpdate(UpdatableRecord<?>... records)
```
Create a batch statement to execute a set of UPDATE queries in batch mode (with bind values) according to UpdatableRecord.update() semantics.

See Also:

batchStore(UpdatableRecord...), UpdatableRecord.update(), Statement.executeBatch()

batchUpdate
```
@Support
Batch batchUpdate(Collection<? extends UpdatableRecord<?>> records)
```
Create a batch statement to execute a set of UPDATE queries in batch mode (with bind values) according to UpdatableRecord.update() semantics.

See Also:

batchStore(UpdatableRecord...), UpdatableRecord.update(), Statement.executeBatch()

batchDelete
```
@Support
Batch batchDelete(UpdatableRecord<?>... records)
```
Create a batch statement to execute a set of DELETE queries in batch mode (with bind values) according to UpdatableRecord.delete() sematics.
This batch operation can be executed in two modes:

With Settings.getStatementType() == StatementType.PREPARED_STATEMENT (the default)

In this mode, record order is preserved as much as possible, as long as two subsequent records generate the same SQL (with bind variables). The number of executed batch operations corresponds to [number of distinct rendered SQL statements]. In the worst case, this corresponds to the number of total records.
The record type order is preserved in the way they are passed to this method. This is an example of how statements will be ordered:
```
 // Let's assume a[n] are all of the same type, just as b[n], c[n]...
 int[] result = create.batchDelete(a1, a2, a3, b1, a4, c1, c2, a5)
                      .execute();
 
```
The above results in result.length == 8 and the following 5 separate batch statements:
1. DELETE a1, a2, a3
2. DELETE b1
3. DELETE a4
4. DELETE c1, c2
5. DELETE a5
With Settings.getStatementType() == StatementType.STATIC_STATEMENT

This mode may be better for large and complex batch delete operations, as the order of records is preserved entirely, and jOOQ can guarantee that only a single batch statement is serialised to the database.
See Also:

UpdatableRecord.delete(), Statement.executeBatch()

batchDelete
```
@Support
Batch batchDelete(Collection<? extends UpdatableRecord<?>> records)
```
Create a batch statement to execute a set of DELETE queries in batch mode (with bind values) according to UpdatableRecord.delete() sematics.

See Also:

batchDelete(UpdatableRecord...), UpdatableRecord.delete(), Statement.executeBatch()

ddl
```
Queries ddl(Catalog catalog)
```
Generate the complete creation script for the entire catalog.

See Also:

ddl(Catalog, DDLExportConfiguration)

ddl
```
Queries ddl(Catalog schema,
            DDLExportConfiguration configuration)
```
Generate a partial creation script for the entire catalog.
The following DDLFlag can be set:
- DDLFlag.SCHEMA: If set, the catalog's SCHEMA specification will be generated.
- DDLFlag.TABLE: If set, the schema's TABLE specification will be generated.
- DDLFlag.PRIMARY_KEY: If set, a potential PRIMARY KEY constraint is specified inline with the table.
- DDLFlag.UNIQUE: If set, any potential UNIQUE constraint is specified inline with the table.
- DDLFlag.FOREIGN_KEY: If set, any potential FOREIGN KEY constraint is specified after all the tables, as a separate ALTER TABLE .. ADD CONSTRAINT statement.

ddl
```
Queries ddl(Catalog schema,
            DDLFlag... flags)
```
Generate a partial creation script for the entire catalog.

See Also:

ddl(Catalog, DDLExportConfiguration)

ddl
```
Queries ddl(Schema schema)
```
Generate the complete creation script for the entire schema.

See Also:

ddl(Schema, DDLExportConfiguration)

ddl
```
Queries ddl(Schema schema,
            DDLExportConfiguration configuration)
```
Generate a partial creation script for the entire schema.
The following DDLFlag can be set:
- DDLFlag.TABLE: If set, the schema's TABLE specification will be generated.
- DDLFlag.PRIMARY_KEY: If set, a potential PRIMARY KEY constraint is specified inline with the table.
- DDLFlag.UNIQUE: If set, any potential UNIQUE constraint is specified inline with the table.
- DDLFlag.FOREIGN_KEY: If set, any potential FOREIGN KEY constraint is specified after all the tables, as a separate ALTER TABLE .. ADD CONSTRAINT statement.

ddl
```
Queries ddl(Schema schema,
            DDLFlag... flags)
```
Generate a partial creation script for the entire schema.

See Also:

ddl(Schema, DDLExportConfiguration)

ddl
```
Queries ddl(Table<?> table)
```
Generate the complete creation script for a table.

See Also:

ddl(Table, DDLExportConfiguration)

ddl
```
Queries ddl(Table<?> table,
            DDLExportConfiguration configuration)
```
Generate a partial creation script for a table.
The following DDLFlag can be set:
- DDLFlag.TABLE: If not set, this will generate nothing at all.
- DDLFlag.PRIMARY_KEY: If set, a potential PRIMARY KEY constraint is specified inline with the table.
- DDLFlag.UNIQUE: If set, any potential UNIQUE constraint is specified inline with the table.
- DDLFlag.FOREIGN_KEY: If set, any potential FOREIGN KEY constraint is specified inline with the table.

ddl
```
Queries ddl(Table<?> table,
            DDLFlag... flags)
```
Generate a partial creation script for a table.

See Also:

ddl(Table, DDLExportConfiguration)

ddl
```
Queries ddl(Table<?>... tables)
```
Generate the complete creation script for tables.

See Also:

ddl(Table[], DDLExportConfiguration)

ddl
```
Queries ddl(Table<?>[] tables,
            DDLExportConfiguration configuration)
```
Generate the complete creation script for tables.
The following DDLFlag can be set:
- DDLFlag.TABLE: If not set, this will generate nothing at all.
- DDLFlag.PRIMARY_KEY: If set, a potential PRIMARY KEY constraint is specified inline with the table.
- DDLFlag.UNIQUE: If set, any potential UNIQUE constraint is specified inline with the table.
- DDLFlag.FOREIGN_KEY: If set, any potential FOREIGN KEY constraint is specified inline with the table.

ddl
```
Queries ddl(Table<?>[] tables,
            DDLFlag... flags)
```
Generate the complete creation script for tables.

See Also:

ddl(Table[], DDLExportConfiguration)

ddl
```
Queries ddl(Collection<? extends Table<?>> tables)
```
Generate the complete creation script for tables.

See Also:

ddl(Collection, DDLExportConfiguration)

ddl
```
Queries ddl(Collection<? extends Table<?>> tables,
            DDLFlag... flags)
```
Generate the complete creation script for tables.
The following DDLFlag can be set:
- DDLFlag.TABLE: If not set, this will generate nothing at all.
- DDLFlag.PRIMARY_KEY: If set, a potential PRIMARY KEY constraint is specified inline with the table.
- DDLFlag.UNIQUE: If set, any potential UNIQUE constraint is specified inline with the table.
- DDLFlag.FOREIGN_KEY: If set, any potential FOREIGN KEY constraint is specified inline with the table.

ddl

Queries ddl(Collection<? extends Table<?>> tables,
            DDLExportConfiguration configuration)

Generate the complete creation script for tables.

See Also:: ddl(Collection, DDLExportConfiguration)

setCatalog

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
RowCountQuery setCatalog(String catalog)

Set the current catalog to a new value.

See Also:: DSL.catalog(Name)

setCatalog

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
RowCountQuery setCatalog(Name catalog)

Set the current catalog to a new value.

See Also:: DSL.catalog(Name)

setCatalog

@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
RowCountQuery setCatalog(Catalog catalog)

Set the current catalog to a new value.

setSchema

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
RowCountQuery setSchema(String schema)

Set the current schema to a new value.

See Also:: DSL.schema(Name), DSL.setSchema(String)

setSchema

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
RowCountQuery setSchema(Name schema)

Set the current schema to a new value.

See Also:: DSL.schema(Name), DSL.setSchema(Name)

setSchema

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
RowCountQuery setSchema(Schema schema)

Set the current schema to a new value.

See Also:: DSL.setSchema(Schema)

commentOnTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnTable(String tableName)

Create a new DSL COMMENT ON TABLE statement.

See Also:: DSL.commentOnTable(String), AlterTableStep.comment(Comment)

commentOnTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnTable(Name tableName)

Create a new DSL COMMENT ON TABLE statement.

See Also:: DSL.commentOnTable(Name), AlterTableStep.comment(Comment)

commentOnTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnTable(Table<?> table)

Create a new DSL COMMENT ON TABLE statement.

See Also:: DSL.commentOnTable(Table), AlterTableStep.comment(Comment)

commentOnView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnView(String viewName)

Create a new DSL COMMENT ON VIEW statement.

See Also:: DSL.commentOnView(String), AlterViewStep.comment(Comment)

commentOnView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnView(Name viewName)

Create a new DSL COMMENT ON VIEW statement.

See Also:: DSL.commentOnView(Name), AlterViewStep.comment(Comment)

commentOnView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnView(Table<?> view)

Create a new DSL COMMENT ON VIEW statement.

See Also:: DSL.commentOnView(Table), AlterViewStep.comment(Comment)

commentOnColumn

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnColumn(Name columnName)

Create a new DSL COMMENT ON COLUMN statement.

See Also:: DSL.commentOnColumn(Name)

commentOnColumn

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CommentOnIsStep commentOnColumn(Field<?> field)

Create a new DSL COMMENT ON COLUMN statement.

See Also:: DSL.commentOnColumn(Field)

createSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
CreateSchemaFinalStep createSchema(String schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSL.createSchema(String)

createSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
CreateSchemaFinalStep createSchema(Name schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSL.createSchema(Name)

createSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
CreateSchemaFinalStep createSchema(Schema schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSL.createSchema(Schema)

createSchemaIfNotExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
CreateSchemaFinalStep createSchemaIfNotExists(String schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSL.createSchemaIfNotExists(String)

createSchemaIfNotExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
CreateSchemaFinalStep createSchemaIfNotExists(Name schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSL.createSchemaIfNotExists(Name)

createSchemaIfNotExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
CreateSchemaFinalStep createSchemaIfNotExists(Schema schema)

Create a new DSL CREATE SCHEMA statement.

See Also:: DSL.createSchemaIfNotExists(Schema)

createTable
```
@Support
CreateTableColumnStep createTable(String table)
```
Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTable(String)

createTable
```
@Support
CreateTableColumnStep createTable(Name table)
```
Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTable(Name)

createTable
```
@Support
CreateTableColumnStep createTable(Table<?> table)
```
Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTable(Table)

createTableIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
CreateTableColumnStep createTableIfNotExists(String table)

Create a new DSL CREATE TABLE statement.

See Also:: DSL.createTableIfNotExists(String)

createTableIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
CreateTableColumnStep createTableIfNotExists(Name table)

Create a new DSL CREATE TABLE statement.

See Also:: DSL.createTableIfNotExists(Name)

createTableIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
CreateTableColumnStep createTableIfNotExists(Table<?> table)

Create a new DSL CREATE TABLE statement.

See Also:: DSL.createTableIfNotExists(Table)

createTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
CreateTableColumnStep createTemporaryTable(String table)

Create a new DSL CREATE TEMPORARY TABLE statement.

See Also:: DSL.createTemporaryTable(String)

createTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
CreateTableColumnStep createTemporaryTable(Name table)

Create a new DSL CREATE TEMPORARY TABLE statement.

See Also:: DSL.createTemporaryTable(Name)

createTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
CreateTableColumnStep createTemporaryTable(Table<?> table)

Create a new DSL CREATE TEMPORARY TABLE statement.

See Also:: DSL.createTemporaryTable(Table)

createGlobalTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
CreateTableColumnStep createGlobalTemporaryTable(String table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSL.createGlobalTemporaryTable(String)

createGlobalTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
CreateTableColumnStep createGlobalTemporaryTable(Name table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSL.createGlobalTemporaryTable(Name)

createGlobalTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
CreateTableColumnStep createGlobalTemporaryTable(Table<?> table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:: DSL.createGlobalTemporaryTable(Table)

createView

@Support
CreateViewAsStep<Record> createView(String view,
                                    String... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSL.createView(String, String...)

createView

@Support
CreateViewAsStep<Record> createView(Name view,
                                    Name... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSL.createView(Name, Name...)

createView

@Support
CreateViewAsStep<Record> createView(Table<?> view,
                                    Field<?>... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSL.createView(Table, Field...)

createView
```
@Support
CreateViewAsStep<Record> createView(String view,
                                    Function<? super Field<?>,? extends String> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView
```
@Support
CreateViewAsStep<Record> createView(String view,
                                    BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView
```
@Support
CreateViewAsStep<Record> createView(Name view,
                                    Function<? super Field<?>,? extends Name> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView
```
@Support
CreateViewAsStep<Record> createView(Name view,
                                    BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView
```
@Support
CreateViewAsStep<Record> createView(Table<?> view,
                                    Function<? super Field<?>,? extends Field<?>> fieldNameFunction)
```
Create a new DSL CREATE VIEW statement.
This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView

@Support
CreateViewAsStep<Record> createView(Table<?> view,
                                    BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(String view,
                                             String... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:: DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(Name view,
                                             Name... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:: DSL.createOrReplaceView(Name, Name...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(Table<?> view,
                                             Field<?>... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:: DSL.createOrReplaceView(Table, Field...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(String view,
                                             Function<? super Field<?>,? extends String> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(String view,
                                             BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(Name view,
                                             Function<? super Field<?>,? extends Name> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(Name view,
                                             BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(Table<?> view,
                                             Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Support({AURORA_POSTGRES,DB2,H2,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
CreateViewAsStep<Record> createOrReplaceView(Table<?> view,
                                             BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createOrReplaceView(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(String view,
                                               String... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(Name view,
                                               Name... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSL.createViewIfNotExists(Name, Name...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(Table<?> view,
                                               Field<?>... fields)

Create a new DSL CREATE VIEW statement.

See Also:: DSL.createViewIfNotExists(Table, Field...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(String view,
                                               Function<? super Field<?>,? extends String> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(String view,
                                               BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(Name view,
                                               Function<? super Field<?>,? extends Name> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(Name view,
                                               BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(Table<?> view,
                                               Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateViewAsStep<Record> createViewIfNotExists(Table<?> view,
                                               BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:: DSL.createViewIfNotExists(String, String...)

createType
```
@Support({H2,POSTGRES})
CreateTypeStep createType(String type)
```
Create a new DSL CREATE TYPE statement.

See Also:

DSL.createType(String)

createType
```
@Support({H2,POSTGRES})
CreateTypeStep createType(Name type)
```
Create a new DSL CREATE TYPE statement.

See Also:

DSL.createType(Name)

dropType
```
@Support({H2,POSTGRES})
DropTypeStep dropType(String type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(String)

dropType
```
@Support({H2,POSTGRES})
DropTypeStep dropType(Name type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(Name)

dropType
```
@Support({H2,POSTGRES})
DropTypeStep dropType(String... type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(String...)

dropType
```
@Support({H2,POSTGRES})
DropTypeStep dropType(Name... type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(Name...)

dropType
```
@Support({H2,POSTGRES})
DropTypeStep dropType(Collection<?> type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(Collection)

dropTypeIfExists
```
@Support({H2,POSTGRES})
DropTypeStep dropTypeIfExists(String type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(String)

dropTypeIfExists
```
@Support({H2,POSTGRES})
DropTypeStep dropTypeIfExists(Name type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(Name)

dropTypeIfExists
```
@Support({H2,POSTGRES})
DropTypeStep dropTypeIfExists(String... type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(String...)

dropTypeIfExists
```
@Support({H2,POSTGRES})
DropTypeStep dropTypeIfExists(Name... type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(Name...)

dropTypeIfExists
```
@Support({H2,POSTGRES})
DropTypeStep dropTypeIfExists(Collection<?> type)
```
Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(Collection)

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createIndex()

Create a new DSL CREATE INDEX statement.

See Also:: DSL.createIndex()

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createIndex(String index)

Create a new DSL CREATE INDEX statement.

See Also:: DSL.createIndex(String)

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createIndex(Name index)

Create a new DSL CREATE INDEX statement.

See Also:: DSL.createIndex(Name)

createIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createIndex(Index index)

Create a new DSL CREATE INDEX statement.

See Also:: DSL.createIndex(Index)

createIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateIndexStep createIndexIfNotExists(String index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:: DSL.createIndexIfNotExists(String)

createIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateIndexStep createIndexIfNotExists(Name index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:: DSL.createIndexIfNotExists(Name)

createIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
CreateIndexStep createIndexIfNotExists(Index index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:: DSL.createIndexIfNotExists(Index)

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createUniqueIndex()

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createUniqueIndex()

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createUniqueIndex(String index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createIndex(String)

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createUniqueIndex(Name index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createIndex(Name)

createUniqueIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
CreateIndexStep createUniqueIndex(Index index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createIndex(Index)

createUniqueIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
CreateIndexStep createUniqueIndexIfNotExists(String index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createIndex(String)

createUniqueIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
CreateIndexStep createUniqueIndexIfNotExists(Name index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createIndex(Name)

createUniqueIndexIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
CreateIndexStep createUniqueIndexIfNotExists(Index index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:: DSL.createIndex(Index)

createSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
CreateSequenceFlagsStep createSequence(String sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSL.createSequence(String)

createSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
CreateSequenceFlagsStep createSequence(Name sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSL.createSequence(Name)

createSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
CreateSequenceFlagsStep createSequence(Sequence<?> sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSL.createSequence(String)

createSequenceIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
CreateSequenceFlagsStep createSequenceIfNotExists(String sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSL.createSequenceIfNotExists(String)

createSequenceIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
CreateSequenceFlagsStep createSequenceIfNotExists(Name sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSL.createSequenceIfNotExists(Name)

createSequenceIfNotExists

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
CreateSequenceFlagsStep createSequenceIfNotExists(Sequence<?> sequence)

Create a new DSL CREATE SEQUENCE statement.

See Also:: DSL.createSequenceIfNotExists(Sequence)

alterSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
AlterSequenceStep<BigInteger> alterSequence(String sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSL.alterSequence(String)

alterSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
AlterSequenceStep<BigInteger> alterSequence(Name sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSL.alterSequence(Name)

alterSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> AlterSequenceStep<T> alterSequence(Sequence<T> sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSL.alterSequence(Sequence)

alterSequenceIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES})
AlterSequenceStep<BigInteger> alterSequenceIfExists(String sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSL.alterSequenceIfExists(String)

alterSequenceIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES})
AlterSequenceStep<BigInteger> alterSequenceIfExists(Name sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSL.alterSequenceIfExists(Name)

alterSequenceIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES})
<T extends Number> AlterSequenceStep<T> alterSequenceIfExists(Sequence<T> sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:: DSL.alterSequenceIfExists(Sequence)

alterTable
```
@Support
AlterTableStep alterTable(String table)
```
Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTable(String)

alterTable
```
@Support
AlterTableStep alterTable(Name table)
```
Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTable(Name)

alterTable
```
@Support
AlterTableStep alterTable(Table<?> table)
```
Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTable(Table)

alterTableIfExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,ORACLE,POSTGRES,SQLSERVER})
AlterTableStep alterTableIfExists(String table)

Create a new DSL ALTER TABLE statement.

See Also:: DSL.alterTableIfExists(String)

alterTableIfExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,ORACLE,POSTGRES,SQLSERVER})
AlterTableStep alterTableIfExists(Name table)

Create a new DSL ALTER TABLE statement.

See Also:: DSL.alterTableIfExists(Name)

alterTableIfExists

@Support({AURORA_POSTGRES,DB2,H2,MARIADB,ORACLE,POSTGRES,SQLSERVER})
AlterTableStep alterTableIfExists(Table<?> table)

Create a new DSL ALTER TABLE statement.

See Also:: DSL.alterTableIfExists(Table)

alterSchema

@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES,VERTICA})
AlterSchemaStep alterSchema(String schema)

Create a new DSL ALTER SCHEMA statement.

See Also:: DSL.alterSchema(String)

alterSchema

@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES,VERTICA})
AlterSchemaStep alterSchema(Name schema)

Create a new DSL ALTER SCHEMA statement.

See Also:: DSL.alterSchema(Name)

alterSchema

@Support({AURORA_POSTGRES,H2,HSQLDB,POSTGRES,VERTICA})
AlterSchemaStep alterSchema(Schema schema)

Create a new DSL ALTER SCHEMA statement.

See Also:: DSL.alterSchema(Schema)

alterSchemaIfExists
```
@Support(H2)
AlterSchemaStep alterSchemaIfExists(String schema)
```
Create a new DSL ALTER SCHEMA statement.

See Also:

DSL.alterSchemaIfExists(String)

alterSchemaIfExists
```
@Support(H2)
AlterSchemaStep alterSchemaIfExists(Name schema)
```
Create a new DSL ALTER SCHEMA statement.

See Also:

DSL.alterSchemaIfExists(Name)

alterSchemaIfExists
```
@Support(H2)
AlterSchemaStep alterSchemaIfExists(Schema schema)
```
Create a new DSL ALTER SCHEMA statement.

See Also:

DSL.alterSchemaIfExists(Schema)

alterView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
AlterViewStep alterView(String view)

Create a new DSL ALTER VIEW statement.

See Also:: DSL.alterView(String)

alterView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
AlterViewStep alterView(Name view)

Create a new DSL ALTER VIEW statement.

See Also:: DSL.alterView(Name)

alterView

@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
AlterViewStep alterView(Table<?> view)

Create a new DSL ALTER VIEW statement.

See Also:: DSL.alterView(Table)

alterViewIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES,SQLSERVER})
AlterViewStep alterViewIfExists(String view)

Create a new DSL ALTER VIEW statement.

See Also:: DSL.alterViewIfExists(String)

alterViewIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES,SQLSERVER})
AlterViewStep alterViewIfExists(Name view)

Create a new DSL ALTER VIEW statement.

See Also:: DSL.alterViewIfExists(Name)

alterViewIfExists

@Support({AURORA_POSTGRES,ORACLE,POSTGRES,SQLSERVER})
AlterViewStep alterViewIfExists(Table<?> view)

Create a new DSL ALTER VIEW statement.

See Also:: DSL.alterViewIfExists(Table)

alterIndex

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
AlterIndexOnStep alterIndex(String index)

Create a new DSL ALTER INDEX statement.

See Also:: DSL.alterIndex(String)

alterIndex

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
AlterIndexOnStep alterIndex(Name index)

Create a new DSL ALTER INDEX statement.

See Also:: DSL.alterIndex(Name)

alterIndex

@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
AlterIndexOnStep alterIndex(Index index)

Create a new DSL ALTER INDEX statement.

See Also:: DSL.alterIndex(Name)

alterIndexIfExists

@Support({AURORA_POSTGRES,DB2,H2,ORACLE,POSTGRES})
AlterIndexStep alterIndexIfExists(String index)

Create a new DSL ALTER INDEX statement.

See Also:: DSL.alterIndexIfExists(String)

alterIndexIfExists

@Support({AURORA_POSTGRES,DB2,H2,ORACLE,POSTGRES})
AlterIndexStep alterIndexIfExists(Name index)

Create a new DSL ALTER INDEX statement.

See Also:: DSL.alterIndexIfExists(Name)

alterIndexIfExists

@Support({AURORA_POSTGRES,DB2,H2,ORACLE,POSTGRES})
AlterIndexStep alterIndexIfExists(Index index)

Create a new DSL ALTER INDEX statement.

See Also:: DSL.alterIndexIfExists(Name)

dropSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
DropSchemaStep dropSchema(String schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSL.dropSchema(String)

dropSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
DropSchemaStep dropSchema(Name schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSL.dropSchema(Name)

dropSchema

@Support({AURORA_POSTGRES,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
DropSchemaStep dropSchema(Schema schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSL.dropSchema(Schema)

dropSchemaIfExists

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
DropSchemaStep dropSchemaIfExists(String schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSL.dropSchemaIfExists(String)

dropSchemaIfExists

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
DropSchemaStep dropSchemaIfExists(Name schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSL.dropSchemaIfExists(Name)

dropSchemaIfExists

@Support({AURORA_POSTGRES,DB2,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
DropSchemaStep dropSchemaIfExists(Schema schema)

Create a new DSL DROP SCHEMA statement.

See Also:: DSL.dropSchemaIfExists(Schema)

dropView
```
@Support
DropViewFinalStep dropView(String view)
```
Create a new DSL DROP VIEW statement.

See Also:

DSL.dropView(String)

dropView
```
@Support
DropViewFinalStep dropView(Name view)
```
Create a new DSL DROP VIEW statement.

See Also:

DSL.dropView(Name)

dropView
```
@Support
DropViewFinalStep dropView(Table<?> view)
```
Create a new DSL DROP VIEW statement.

See Also:

DSL.dropView(Table)

dropViewIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
DropViewFinalStep dropViewIfExists(String view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSL.dropViewIfExists(String)

dropViewIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
DropViewFinalStep dropViewIfExists(Name view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSL.dropViewIfExists(Name)

dropViewIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
DropViewFinalStep dropViewIfExists(Table<?> view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSL.dropViewIfExists(Table)

dropTable
```
@Support
DropTableStep dropTable(String table)
```
Create a new DSL DROP TABLE statement.

See Also:

DSL.dropTable(String)

dropTable
```
@Support
DropTableStep dropTable(Name table)
```
Create a new DSL DROP TABLE statement.

See Also:

DSL.dropTable(Name)

dropTable
```
@Support
DropTableStep dropTable(Table<?> table)
```
Create a new DSL DROP TABLE statement.

See Also:

DSL.dropTable(Table)

dropTableIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
DropTableStep dropTableIfExists(String table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSL.dropTableIfExists(String)

dropTableIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
DropTableStep dropTableIfExists(Name table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSL.dropTableIfExists(Name)

dropTableIfExists

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
DropTableStep dropTableIfExists(Table<?> table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:: DSL.dropTableIfExists(Table)

dropTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
DropTableStep dropTemporaryTable(String table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:: DSL.dropTemporaryTable(String)

dropTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
DropTableStep dropTemporaryTable(Name table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:: DSL.dropTemporaryTable(Name)

dropTemporaryTable

@Support({AURORA_MYSQL,AURORA_POSTGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
DropTableStep dropTemporaryTable(Table<?> table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:: DSL.dropTemporaryTable(Table)

dropIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
DropIndexOnStep dropIndex(String index)

Create a new DSL DROP INDEX statement.

See Also:: DSL.dropIndex(String)

dropIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
DropIndexOnStep dropIndex(Name index)

Create a new DSL DROP INDEX statement.

See Also:: DSL.dropIndex(Name)

dropIndex

@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
DropIndexOnStep dropIndex(Index index)

Create a new DSL DROP INDEX statement.

See Also:: DSL.dropIndex(Name)

dropIndexIfExists
```
@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
DropIndexOnStep dropIndexIfExists(String index)
```
Create a new DSL DROP INDEX IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropIndexIfExists(String)

dropIndexIfExists
```
@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
DropIndexOnStep dropIndexIfExists(Name index)
```
Create a new DSL DROP INDEX IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropIndexIfExists(Name)

dropIndexIfExists
```
@Support({ACCESS,ASE,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
DropIndexOnStep dropIndexIfExists(Index index)
```
Create a new DSL DROP INDEX IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropIndexIfExists(Name)

dropSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
DropSequenceFinalStep dropSequence(String sequence)

Create a new DSL DROP SEQUENCE statement.

See Also:: DSL.dropSequence(String)

dropSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
DropSequenceFinalStep dropSequence(Name sequence)

Create a new DSL DROP SEQUENCE statement.

See Also:: DSL.dropSequence(Name)

dropSequence

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
DropSequenceFinalStep dropSequence(Sequence<?> sequence)

Create a new DSL DROP SEQUENCE statement.

See Also:: DSL.dropSequence(Sequence)

dropSequenceIfExists
```
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
DropSequenceFinalStep dropSequenceIfExists(String sequence)
```
Create a new DSL DROP SEQUENCE IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropSequenceIfExists(String)

dropSequenceIfExists
```
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
DropSequenceFinalStep dropSequenceIfExists(Name sequence)
```
Create a new DSL DROP SEQUENCE IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropSequenceIfExists(Name)

dropSequenceIfExists
```
@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
DropSequenceFinalStep dropSequenceIfExists(Sequence<?> sequence)
```
Create a new DSL DROP SEQUENCE IF EXISTS statement.
If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropSequenceIfExists(Sequence)

truncate
```
@Support
TruncateIdentityStep<Record> truncate(String table)
```
Create a new DSL truncate statement.
Synonym for truncateTable(String)

truncate
```
@Support
TruncateIdentityStep<Record> truncate(Name table)
```
Create a new DSL truncate statement.
Synonym for truncateTable(Name)

truncate

@Support
<R extends Record> TruncateIdentityStep<R> truncate(Table<R> table)

Create a new DSL truncate statement.

Synonym for truncateTable(Table)

truncateTable
```
@Support
TruncateIdentityStep<Record> truncateTable(String table)
```
Create a new DSL truncate statement.
Example:
```
 DSLContext create = DSL.using(configuration);

 create.truncate(table)
       .execute();
 
```
Emulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:
Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:
```
 create.truncate(table)
       .restartIdentity()
       .cascade()
       .execute();
 
```
These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.
See Also:

truncate(Table)

truncateTable
```
@Support
TruncateIdentityStep<Record> truncateTable(Name table)
```
Create a new DSL truncate statement.
Example:
```
 DSLContext create = DSL.using(configuration);

 create.truncate(table)
       .execute();
 
```
Emulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:
Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:
```
 create.truncate(table)
       .restartIdentity()
       .cascade()
       .execute();
 
```
These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.
See Also:

truncate(Name)

truncateTable
```
@Support
<R extends Record> TruncateIdentityStep<R> truncateTable(Table<R> table)
```
Create a new DSL truncate statement.
Example:
```
 DSLContext create = DSL.using(configuration);

 create.truncate(table)
       .execute();
 
```
Emulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:
Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:
```
 create.truncate(table)
       .restartIdentity()
       .cascade()
       .execute();
 
```
These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.

grant

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
GrantOnStep grant(Privilege privilege)

Grant a privilege on a table to user or role.

grant

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
GrantOnStep grant(Privilege... privileges)

Grant privileges on a table to user or role.

grant

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
GrantOnStep grant(Collection<? extends Privilege> privileges)

Grant privileges on a table to user or role.

revoke

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
RevokeOnStep revoke(Privilege privilege)

Revoke a privilege on table from user or role.

revoke

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
RevokeOnStep revoke(Privilege... privileges)

Revoke privileges on table from user or role.

revoke

@Support({AURORA_MYSQL,AURORA_POSTGRES,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
RevokeOnStep revoke(Collection<? extends Privilege> privileges)

Revoke privileges on table from user or role.

revokeGrantOptionFor

@Support({AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
RevokeOnStep revokeGrantOptionFor(Privilege privilege)

Revoke grant option for a privilege on a table from user or role.

revokeGrantOptionFor

@Support({AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
RevokeOnStep revokeGrantOptionFor(Privilege... privileges)

Revoke grant option for some privileges on a table from user or role.

revokeGrantOptionFor

@Support({AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
RevokeOnStep revokeGrantOptionFor(Collection<? extends Privilege> privileges)

Revoke grant option for some privileges on a table from user or role.

lastID
```
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DERBY,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLITE,SQLSERVER,SYBASE})
BigInteger lastID()
           throws DataAccessException
```
Retrieve the last inserted ID.
This is implemented for the following dialects:
- SQLDialect.ACCESS: Using @@identity
- SQLDialect.ASE: Using @@identity
- SQLDialect.CUBRID: Using last_insert_id()
- SQLDialect.DERBY: Using identity_val_local()
- SQLDialect.H2: Using identity()
- SQLDialect.HSQLDB: Using identity()
- SQLDialect.INFORMIX: Using dbinfo('sqlca.sqlerrd1')
- SQLDialect.INGRES: Using last_identity()
- SQLDialect.MARIADB: Using last_insert_id()
- SQLDialect.MYSQL: Using last_insert_id()
- SQLDialect.POSTGRES: Using lastval()
- SQLDialect.SQLITE: Using last_insert_rowid()
- SQLDialect.SQLSERVER: Using @@identity
- SQLDialect.SYBASE: Using @@identity
- SQLDialect.VERTICA: Using last_insert_id()
Returns:

The last inserted ID. This may be null in some dialects, if no such number is available.

Throws:

DataAccessException - if something went wrong executing the query

nextval

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
BigInteger nextval(String sequence)
            throws DataAccessException

Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:: DataAccessException - if something went wrong executing the query

nextval

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
BigInteger nextval(Name sequence)
            throws DataAccessException

Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:: DataAccessException - if something went wrong executing the query

nextval

@Support({AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> T nextval(Sequence<T> sequence)
                      throws DataAccessException

Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:: DataAccessException - if something went wrong executing the query

currval

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
BigInteger currval(String sequence)
            throws DataAccessException

Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:: DataAccessException - if something went wrong executing the query

currval

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
BigInteger currval(Name sequence)
            throws DataAccessException

Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:: DataAccessException - if something went wrong executing the query

currval

@Support({AURORA_POSTGRES,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> T currval(Sequence<T> sequence)
                      throws DataAccessException

Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:: DataAccessException - if something went wrong executing the query

newRecord
```
<R extends UDTRecord<R>> R newRecord(UDT<R> type)
```
Create a new UDTRecord.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

R - The generic record type

Parameters:

type - The UDT describing records of type <R>

Returns:

The new record

newRecord
```
<R extends Record> R newRecord(Table<R> table)
```
Create a new Record that can be inserted into the corresponding table.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

R - The generic record type

Parameters:

table - The table holding records of type <R>

Returns:

The new record

newRecord
```
<R extends Record> R newRecord(Table<R> table,
                               Object source)
```
Create a new pre-filled Record that can be inserted into the corresponding table.
This performs roughly the inverse operation of Record.into(Class)
The resulting record will have its internal "changed" flags set to true for all values. This means that UpdatableRecord.store() will perform an INSERT statement. If you wish to store the record using an UPDATE statement, use executeUpdate(UpdatableRecord) instead.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

R - The generic record type

Parameters:

table - The table holding records of type <R>

source - The source to be used to fill the new record

Returns:

The new record

Throws:

MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

See Also:

Record.from(Object), Record.into(Class)

newRecord
```
Record newRecord(Field<?>... fields)
```
Create a new empty Record.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newRecord
```
Record newRecord(Collection<? extends Field<?>> fields)
```
Create a new empty Record.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newRecord
```
<T1> Record1<T1> newRecord(Field<T1> field1)
```
Create a new empty Record.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord
```
<T1,T2> Record2<T1,T2> newRecord(Field<T1> field1,
                                             Field<T2> field2)
```
Create a new empty Record.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

<T1,T2,T3> Record3<T1,T2,T3> newRecord(Field<T1> field1,
                                                               Field<T2> field2,
                                                               Field<T3> field3)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4> Record4<T1,T2,T3,T4> newRecord(Field<T1> field1,
                                                                                 Field<T2> field2,
                                                                                 Field<T3> field3,
                                                                                 Field<T4> field4)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5> Record5<T1,T2,T3,T4,T5> newRecord(Field<T1> field1,
                                                                                                   Field<T2> field2,
                                                                                                   Field<T3> field3,
                                                                                                   Field<T4> field4,
                                                                                                   Field<T5> field5)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6> Record6<T1,T2,T3,T4,T5,T6> newRecord(Field<T1> field1,
                                                                                                                     Field<T2> field2,
                                                                                                                     Field<T3> field3,
                                                                                                                     Field<T4> field4,
                                                                                                                     Field<T5> field5,
                                                                                                                     Field<T6> field6)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7> Record7<T1,T2,T3,T4,T5,T6,T7> newRecord(Field<T1> field1,
                                                                                                                                       Field<T2> field2,
                                                                                                                                       Field<T3> field3,
                                                                                                                                       Field<T4> field4,
                                                                                                                                       Field<T5> field5,
                                                                                                                                       Field<T6> field6,
                                                                                                                                       Field<T7> field7)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8> Record8<T1,T2,T3,T4,T5,T6,T7,T8> newRecord(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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9> Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9> newRecord(Field<T1> field1,
                                                                                                                                                                           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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> newRecord(Field<T1> field1,
                                                                                                                                                                                                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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> newRecord(Field<T1> field1,
                                                                                                                                                                                                                    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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                        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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                            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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                    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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                        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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                            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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                    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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                        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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                            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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newRecord

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                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 empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new record

newResult
```
<R extends Record> Result<R> newResult(Table<R> table)
```
Create a new empty Result.
The result is attached to this Configuration by default. This result can be used as a container for records.

Type Parameters:

R - The generic record type

Parameters:

table - The table holding records of type <R>

Returns:

The new result

newResult
```
Result<Record> newResult(Field<?>... fields)
```
Create a new empty Record.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newResult
```
Result<Record> newResult(Collection<? extends Field<?>> fields)
```
Create a new empty Record.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newResult
```
<T1> Result<Record1<T1>> newResult(Field<T1> field1)
```
Create a new empty Result.
The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

<T1,T2> Result<Record2<T1,T2>> newResult(Field<T1> field1,
                                                     Field<T2> field2)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3> Result<Record3<T1,T2,T3>> newResult(Field<T1> field1,
                                                                       Field<T2> field2,
                                                                       Field<T3> field3)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4> Result<Record4<T1,T2,T3,T4>> newResult(Field<T1> field1,
                                                                                         Field<T2> field2,
                                                                                         Field<T3> field3,
                                                                                         Field<T4> field4)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5> Result<Record5<T1,T2,T3,T4,T5>> newResult(Field<T1> field1,
                                                                                                           Field<T2> field2,
                                                                                                           Field<T3> field3,
                                                                                                           Field<T4> field4,
                                                                                                           Field<T5> field5)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6> Result<Record6<T1,T2,T3,T4,T5,T6>> newResult(Field<T1> field1,
                                                                                                                             Field<T2> field2,
                                                                                                                             Field<T3> field3,
                                                                                                                             Field<T4> field4,
                                                                                                                             Field<T5> field5,
                                                                                                                             Field<T6> field6)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7> Result<Record7<T1,T2,T3,T4,T5,T6,T7>> newResult(Field<T1> field1,
                                                                                                                                               Field<T2> field2,
                                                                                                                                               Field<T3> field3,
                                                                                                                                               Field<T4> field4,
                                                                                                                                               Field<T5> field5,
                                                                                                                                               Field<T6> field6,
                                                                                                                                               Field<T7> field7)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8> Result<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> newResult(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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9> Result<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> newResult(Field<T1> field1,
                                                                                                                                                                                   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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Result<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> newResult(Field<T1> field1,
                                                                                                                                                                                                        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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Result<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> newResult(Field<T1> field1,
                                                                                                                                                                                                                            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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Result<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Result<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                    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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Result<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                        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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Result<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                            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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Result<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Result<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                    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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Result<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                        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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Result<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                            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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Result<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Result<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                    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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

newResult

<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Result<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The new result

fetch
```
<R extends Record> Result<R> fetch(ResultQuery<R> query)
                            throws DataAccessException
```
Execute a ResultQuery in the context of this DSLContext and return results.

Parameters:

query - The query to execute

Returns:

The result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.fetch()

fetchLazy
```
<R extends Record> Cursor<R> fetchLazy(ResultQuery<R> query)
                                throws DataAccessException
```
Execute a ResultQuery in the context of this DSLContext and return a cursor.

Parameters:

query - The query to execute

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.fetchLazy()

fetchAsync
```
<R extends Record> CompletionStage<Result<R>> fetchAsync(ResultQuery<R> query)
```
Fetch results in a new CompletionStage.
The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Parameters:

query - The query to execute

Returns:

The completion stage. The completed result will never be null.

See Also:

ResultQuery.fetchAsync()

fetchAsync
```
<R extends Record> CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                         ResultQuery<R> query)
```
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.

Parameters:

query - The query to execute

Returns:

The completion stage. The completed result will never be null.

See Also:

ResultQuery.fetchAsync()

fetchStream
```
<R extends Record> Stream<R> fetchStream(ResultQuery<R> query)
                                  throws DataAccessException
```
Execute a ResultQuery in the context of this DSLContext and return a stream.

Parameters:

query - The query to execute

Returns:

The stream

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.stream()

fetchMany
```
<R extends Record> Results fetchMany(ResultQuery<R> query)
                              throws DataAccessException
```
Execute a ResultQuery in the context of this DSLContext and return a cursor.

Parameters:

query - The query to execute

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.fetchMany()

fetchOne
```
<R extends Record> R fetchOne(ResultQuery<R> query)
                       throws DataAccessException,
                              TooManyRowsException
```
Execute a ResultQuery in the context of this DSLContext and return a record.

Parameters:

query - The query to execute

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

ResultQuery.fetchOne()

fetchSingle
```
<R extends Record> R fetchSingle(ResultQuery<R> query)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException
```
Execute a ResultQuery in the context of this DSLContext and return a record.

Parameters:

query - The query to execute

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

ResultQuery.fetchSingle()

fetchOptional
```
<R extends Record> Optional<R> fetchOptional(ResultQuery<R> query)
                                      throws DataAccessException,
                                             TooManyRowsException
```
Execute a ResultQuery in the context of this DSLContext and return a record.

Parameters:

query - The query to execute

Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

ResultQuery.fetchOptional()

fetchValue
```
<T> T fetchValue(Table<? extends Record1<T>> table)
          throws DataAccessException,
                 TooManyRowsException
```
Fetch a single value from a single column table.

Parameters:

table - The table from which to fetch a value

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue
```
<T,R extends Record1<T>> T fetchValue(ResultQuery<R> query)
                                     throws DataAccessException,
                                            TooManyRowsException
```
Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

query - The query to execute

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue
```
<T> T fetchValue(TableField<?,T> field)
          throws DataAccessException,
                 TooManyRowsException
```
Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

field - The field for which to fetch a single value.

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue
```
<T> T fetchValue(Field<T> field)
          throws DataAccessException
```
Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

field - The field for which to fetch a single value.

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

fetchOptionalValue

<T,R extends Record1<T>> Optional<T> fetchOptionalValue(ResultQuery<R> query)
                                                       throws DataAccessException,
                                                              TooManyRowsException,
                                                              InvalidResultException

Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:: query - The query to execute
Returns:: The value.
Throws:: DataAccessException - if something went wrong executing the query; TooManyRowsException - if the query returned more than one record; InvalidResultException - if the query returned a record with more than one value

fetchOptionalValue
```
<T> Optional<T> fetchOptionalValue(TableField<?,T> field)
                            throws DataAccessException,
                                   TooManyRowsException,
                                   InvalidResultException
```
Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

field - The field for which to fetch a single value.

Returns:

The value.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchValues
```
<T> List<T> fetchValues(Table<? extends Record1<T>> table)
                 throws DataAccessException
```
Fetch all values from a single column table.

Parameters:

table - The table from which to fetch values

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchValues
```
<T,R extends Record1<T>> List<T> fetchValues(ResultQuery<R> query)
                                            throws DataAccessException
```
Execute a ResultQuery in the context of this DSLContext and return all values for the only column.

Parameters:

query - The query to execute

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchValues
```
<T> List<T> fetchValues(TableField<?,T> field)
                 throws DataAccessException
```
Fetch all values in a given Table's TableField.

Parameters:

field - The field for which to fetch all values.

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchByExample
```
<R extends TableRecord<R>> Result<R> fetchByExample(R example)
                                             throws DataAccessException
```
Execute a "Query by Example" (QBE) based on an example record.

Parameters:

example - The example record

Returns:

The resulting records matching the example record.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

DSL.condition(Record)

fetchCount
```
int fetchCount(Select<?> query)
        throws DataAccessException
```
Execute a Select query in the context of this DSLContext and return a COUNT(*) value.
This wraps a pre-existing SELECT query in another one to calculate the COUNT(*) value, without modifying the original SELECT. An example:
```
 -- Original query:
 SELECT id, title FROM book WHERE title LIKE '%a%'

 -- Wrapped query:
 SELECT count(*) FROM (
   SELECT id, title FROM book WHERE title LIKE '%a%'
 )
 
```
This is particularly useful for those databases that do not support the COUNT(*) OVER() window function to calculate total results in paged queries.
Parameters:

query - The wrapped query

Returns:

The COUNT(*) result

Throws:

DataAccessException - if something went wrong executing the query

fetchCount
```
int fetchCount(Table<?> table)
        throws DataAccessException
```
Count the number of records in a table.
This executes
```
SELECT COUNT(*) FROM table
```
Parameters:

table - The table whose records to count

Returns:

The number of records in the table

Throws:

DataAccessException - if something went wrong executing the query

fetchCount
```
int fetchCount(Table<?> table,
               Condition condition)
        throws DataAccessException
```
Count the number of records in a table that satisfy a condition.
This executes
```
SELECT COUNT(*) FROM table WHERE condition
```
Parameters:

table - The table whose records to count

condition - The condition to apply

Returns:

The number of records in the table that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchCount
```
int fetchCount(Table<?> table,
               Condition... conditions)
        throws DataAccessException
```
Count the number of records in a table that satisfy a condition.
This executes
```
SELECT COUNT(*) FROM table WHERE condition
```
Convenience API for calling fetchCount(Table, Condition) with DSL.and(Condition...).
Parameters:

table - The table whose records to count

conditions - The conditions to apply

Returns:

The number of records in the table that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchCount
```
int fetchCount(Table<?> table,
               Collection<? extends Condition> conditions)
        throws DataAccessException
```
Count the number of records in a table that satisfy a condition.
This executes
```
SELECT COUNT(*) FROM table WHERE condition
```
Convenience API for calling fetchCount(Table, Condition) with DSL.and(Collection).
Parameters:

table - The table whose records to count

conditions - The conditions to apply

Returns:

The number of records in the table that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchExists
```
boolean fetchExists(Select<?> query)
             throws DataAccessException
```
Check if a Select would return any records, if it were executed.
This wraps a pre-existing SELECT query in another one to check for result existence, without modifying the original SELECT. An example:
```
 -- Original query:
 SELECT id, title FROM book WHERE title LIKE '%a%'

 -- Wrapped query:
 SELECT EXISTS (
   SELECT id, title FROM book WHERE title LIKE '%a%'
 )
 
```
Parameters:

query - The wrapped query

Returns:

The EXISTS(...) result

Throws:

DataAccessException - if something went wrong executing the query

fetchExists
```
boolean fetchExists(Table<?> table)
             throws DataAccessException
```
Check if a table has any records.
This executes
```
SELECT EXISTS(SELECT * FROM table)
```
Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records

Throws:

DataAccessException - if something went wrong executing the query

fetchExists
```
boolean fetchExists(Table<?> table,
                    Condition condition)
             throws DataAccessException
```
Check if a table has any records that satisfy a condition.
This executes
```
SELECT EXISTS(SELECT * FROM table WHERE condition)
```
Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchExists
```
boolean fetchExists(Table<?> table,
                    Condition... conditions)
             throws DataAccessException
```
Check if a table has any records that satisfy a condition.
This executes
```
SELECT EXISTS(SELECT * FROM table WHERE condition)
```
Convenience API for calling fetchExists(Table, Condition) with DSL.and(Condition...).
Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchExists
```
boolean fetchExists(Table<?> table,
                    Collection<? extends Condition> conditions)
             throws DataAccessException
```
Check if a table has any records that satisfy a condition.
This executes
```
SELECT EXISTS(SELECT * FROM table WHERE condition)
```
Convenience API for calling fetchExists(Table, Condition) with DSL.and(Collection).
Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

execute
```
int execute(Query query)
     throws DataAccessException
```
Execute a Query in the context of this DSLContext.

Parameters:

query - The query to execute

Returns:

The number of affected rows

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Query.execute()

fetch
```
@Support
<R extends Record> Result<R> fetch(Table<R> table)
                            throws DataAccessException
```
Execute and return all records for SELECT table.col1, table.col2 FROM table.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch
```
@Support
<R extends Record> Result<R> fetch(Table<R> table,
                                   Condition condition)
                            throws DataAccessException
```
Execute and return all records for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch
```
@Support
<R extends Record> Result<R> fetch(Table<R> table,
                                   Condition... conditions)
                            throws DataAccessException
```
Execute and return all records for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetch(Table, Condition) with DSL.and(Condition...).
Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch
```
@Support
<R extends Record> Result<R> fetch(Table<R> table,
                                   Collection<? extends Condition> conditions)
                            throws DataAccessException
```
Execute and return all records for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetch(Table, Condition) with DSL.and(Collection).
Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchOne
```
@Support
<R extends Record> R fetchOne(Table<R> table)
                       throws DataAccessException,
                              TooManyRowsException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne
```
@Support
<R extends Record> R fetchOne(Table<R> table,
                              Condition condition)
                       throws DataAccessException,
                              TooManyRowsException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne
```
@Support
<R extends Record> R fetchOne(Table<R> table,
                              Condition... conditions)
                       throws DataAccessException,
                              TooManyRowsException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchOne(Table, Condition) with DSL.and(Condition...).
Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne
```
@Support
<R extends Record> R fetchOne(Table<R> table,
                              Collection<? extends Condition> conditions)
                       throws DataAccessException,
                              TooManyRowsException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchOne(Table, Condition) with DSL.and(Collection).
Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
<R extends Record> R fetchSingle(Table<R> table)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException
```
Execute and return exactly one record for SELECT table.col1, table.col2 FROM table.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@Support
<R extends Record> R fetchSingle(Table<R> table,
                                 Condition condition)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException

Execute and return exactly one record for SELECT table.col1, table.col2 FROM table WHERE condition.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query; NoDataFoundException - if the query returned now rows; TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
<R extends Record> R fetchSingle(Table<R> table,
                                 Condition... conditions)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException
```
Execute and return exactly one record for SELECT table.col1, table.col2 FROM table WHERE condition.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchSingle(Table, Condition) with DSL.and(Condition...).
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
<R extends Record> R fetchSingle(Table<R> table,
                                 Collection<? extends Condition> conditions)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException
```
Execute and return exactly one record for SELECT table.col1, table.col2 FROM table WHERE condition.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchSingle(Table, Condition) with DSL.and(Collection).
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle
```
@Support
Record fetchSingle(SelectField<?>... fields)
            throws DataAccessException
```
Execute and return exactly one record for SELECT F1, F2, ..., FN.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle
```
@Support
Record fetchSingle(Collection<? extends SelectField<?>> fields)
            throws DataAccessException
```
Execute and return exactly one record for SELECT F1, F2, ..., FN.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle
```
@Support
<T1> Record1<T1> fetchSingle(SelectField<T1> field1)
                      throws DataAccessException
```
Execute and return exactly one record for SELECT F1, F2, ..., FN.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle
```
@Support
<T1,T2> Record2<T1,T2> fetchSingle(SelectField<T1> field1,
                                               SelectField<T2> field2)
                                        throws DataAccessException
```
Execute and return exactly one record for SELECT F1, F2, ..., FN.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).
Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3> Record3<T1,T2,T3> fetchSingle(SelectField<T1> field1,
                                                                 SelectField<T2> field2,
                                                                 SelectField<T3> field3)
                                                          throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3,T4> Record4<T1,T2,T3,T4> fetchSingle(SelectField<T1> field1,
                                                                                   SelectField<T2> field2,
                                                                                   SelectField<T3> field3,
                                                                                   SelectField<T4> field4)
                                                                            throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3,T4,T5> Record5<T1,T2,T3,T4,T5> fetchSingle(SelectField<T1> field1,
                                                                                                     SelectField<T2> field2,
                                                                                                     SelectField<T3> field3,
                                                                                                     SelectField<T4> field4,
                                                                                                     SelectField<T5> field5)
                                                                                              throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3,T4,T5,T6> Record6<T1,T2,T3,T4,T5,T6> fetchSingle(SelectField<T1> field1,
                                                                                                                       SelectField<T2> field2,
                                                                                                                       SelectField<T3> field3,
                                                                                                                       SelectField<T4> field4,
                                                                                                                       SelectField<T5> field5,
                                                                                                                       SelectField<T6> field6)
                                                                                                                throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3,T4,T5,T6,T7> Record7<T1,T2,T3,T4,T5,T6,T7> fetchSingle(SelectField<T1> field1,
                                                                                                                                         SelectField<T2> field2,
                                                                                                                                         SelectField<T3> field3,
                                                                                                                                         SelectField<T4> field4,
                                                                                                                                         SelectField<T5> field5,
                                                                                                                                         SelectField<T6> field6,
                                                                                                                                         SelectField<T7> field7)
                                                                                                                                  throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3,T4,T5,T6,T7,T8> Record8<T1,T2,T3,T4,T5,T6,T7,T8> fetchSingle(SelectField<T1> field1,
                                                                                                                                                           SelectField<T2> field2,
                                                                                                                                                           SelectField<T3> field3,
                                                                                                                                                           SelectField<T4> field4,
                                                                                                                                                           SelectField<T5> field5,
                                                                                                                                                           SelectField<T6> field6,
                                                                                                                                                           SelectField<T7> field7,
                                                                                                                                                           SelectField<T8> field8)
                                                                                                                                                    throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9> Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                             SelectField<T2> field2,
                                                                                                                                                                             SelectField<T3> field3,
                                                                                                                                                                             SelectField<T4> field4,
                                                                                                                                                                             SelectField<T5> field5,
                                                                                                                                                                             SelectField<T6> field6,
                                                                                                                                                                             SelectField<T7> field7,
                                                                                                                                                                             SelectField<T8> field8,
                                                                                                                                                                             SelectField<T9> field9)
                                                                                                                                                                      throws DataAccessException

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchSingle

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

Execute and return exactly one record for SELECT F1, F2, ..., FN.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:: The record. This is never null.
Throws:: DataAccessException - if something went wrong executing the query

fetchOptional
```
@Support
<R extends Record> Optional<R> fetchOptional(Table<R> table)
                                      throws DataAccessException,
                                             TooManyRowsException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional

@Support
<R extends Record> Optional<R> fetchOptional(Table<R> table,
                                             Condition condition)
                                      throws DataAccessException,
                                             TooManyRowsException

Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The record
Throws:: DataAccessException - if something went wrong executing the query; TooManyRowsException - if the query returned more than one record

fetchOptional

@Support
<R extends Record> Optional<R> fetchOptional(Table<R> table,
                                             Condition... conditions)
                                      throws DataAccessException,
                                             TooManyRowsException

Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchOptional(Table, Condition) with DSL.and(Condition...).

Returns:: The record
Throws:: DataAccessException - if something went wrong executing the query; TooManyRowsException - if the query returned more than one record

fetchOptional

@Support
<R extends Record> Optional<R> fetchOptional(Table<R> table,
                                             Collection<? extends Condition> conditions)
                                      throws DataAccessException,
                                             TooManyRowsException

Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchOptional(Table, Condition) with DSL.and(Collection).

Returns:: The record
Throws:: DataAccessException - if something went wrong executing the query; TooManyRowsException - if the query returned more than one record

fetchAny
```
@Support
<R extends Record> R fetchAny(Table<R> table)
                       throws DataAccessException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table LIMIT 1.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchAny
```
@Support
<R extends Record> R fetchAny(Table<R> table,
                              Condition condition)
                       throws DataAccessException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition LIMIT 1.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchAny
```
@Support
<R extends Record> R fetchAny(Table<R> table,
                              Condition... conditions)
                       throws DataAccessException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition LIMIT 1.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchAny(Table, Condition) with DSL.and(Condition...).
Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchAny
```
@Support
<R extends Record> R fetchAny(Table<R> table,
                              Collection<? extends Condition> conditions)
                       throws DataAccessException
```
Execute and return zero or one record for SELECT table.col1, table.col2 FROM table WHERE condition LIMIT 1.
The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchAny(Table, Condition) with DSL.and(Collection).
Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
<R extends Record> Cursor<R> fetchLazy(Table<R> table)
                                throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
<R extends Record> Cursor<R> fetchLazy(Table<R> table,
                                       Condition condition)
                                throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
<R extends Record> Cursor<R> fetchLazy(Table<R> table,
                                       Condition... conditions)
                                throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchLazy(Table, Condition) with DSL.and(Condition...).
Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy
```
@Support
<R extends Record> Cursor<R> fetchLazy(Table<R> table,
                                       Collection<? extends Condition> conditions)
                                throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchLazy(Table, Condition) with DSL.and(Collection).
Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchAsync
```
@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Table<R> table)
```
Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Returns:

The completion stage. The completed result will never be null.

fetchAsync

@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Table<R> table,
                                                         Condition condition)

Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table WHERE condition.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The completion stage. The completed result will never be null.

fetchAsync
```
@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Table<R> table,
                                                         Condition... condition)
```
Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchAsync(Table, Condition) with DSL.and(Condition...).
Returns:

The completion stage. The completed result will never be null.

fetchAsync
```
@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Table<R> table,
                                                         Collection<? extends Condition> condition)
```
Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchAsync(Table, Condition) with DSL.and(Collection).
Returns:

The completion stage. The completed result will never be null.

fetchAsync

@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                         Table<R> table)

Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The completion stage. The completed result will never be null.

fetchAsync

@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                         Table<R> table,
                                                         Condition condition)

Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table WHERE condition.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:: The completion stage. The completed result will never be null.

fetchAsync

@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                         Table<R> table,
                                                         Condition... conditions)

Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table WHERE condition.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAsync(Executor, Table, Condition) with DSL.and(Condition...).

Returns:: The completion stage. The completed result will never be null.

fetchAsync

@Support
<R extends Record> CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                         Table<R> table,
                                                         Collection<? extends Condition> conditions)

Execute and return all records asynchronously for SELECT table.col1, table.col2 FROM table WHERE condition.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAsync(Executor, Table, Condition) with DSL.and(Collection).

Returns:: The completion stage. The completed result will never be null.

fetchStream
```
@Support
<R extends Record> Stream<R> fetchStream(Table<R> table)
                                  throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@Support
<R extends Record> Stream<R> fetchStream(Table<R> table,
                                         Condition condition)
                                  throws DataAccessException

Execute and return all records lazily for SELECT table.col1, table.col2 FROM table WHERE condition.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Throws:: DataAccessException - if something went wrong executing the query

fetchStream
```
@Support
<R extends Record> Stream<R> fetchStream(Table<R> table,
                                         Condition... conditions)
                                  throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchStream(Table, Condition) with DSL.and(Condition...).
Throws:

DataAccessException - if something went wrong executing the query

fetchStream
```
@Support
<R extends Record> Stream<R> fetchStream(Table<R> table,
                                         Collection<? extends Condition> conditions)
                                  throws DataAccessException
```
Execute and return all records lazily for SELECT table.col1, table.col2 FROM table WHERE condition.
The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.
Convenience API for calling fetchStream(Table, Condition) with DSL.and(Collection).
Throws:

DataAccessException - if something went wrong executing the query

executeInsert
```
@Support
int executeInsert(TableRecord<?> record)
           throws DataAccessException
```
Insert one record.
This executes something like the following statement:
```
INSERT INTO [table] ... VALUES [record] 
```
Unlike UpdatableRecord.store(), this does not change any of the argument record's internal "changed" flags, such that a subsequent call to UpdatableRecord.store() might lead to another INSERT statement being executed.
Returns:

The number of inserted records

Throws:

DataAccessException - if something went wrong executing the query

executeUpdate

@Support
int executeUpdate(UpdatableRecord<?> record)
           throws DataAccessException

Update a table. UPDATE [table] SET [modified values in record] WHERE [record is supplied record]

Returns:: The number of updated records
Throws:: DataAccessException - if something went wrong executing the query

executeUpdate

@Support
int executeUpdate(TableRecord<?> record,
                  Condition condition)
           throws DataAccessException

Update a table. UPDATE [table] SET [modified values in record] WHERE [condition]

Returns:: The number of updated records
Throws:: DataAccessException - if something went wrong executing the query

executeDelete

@Support
int executeDelete(UpdatableRecord<?> record)
           throws DataAccessException

Delete a record from a table. DELETE FROM [table] WHERE [record is supplied record]

Returns:: The number of deleted records
Throws:: DataAccessException - if something went wrong executing the query

executeDelete

@Support
int executeDelete(TableRecord<?> record,
                  Condition condition)
           throws DataAccessException

Delete a record from a table. DELETE FROM [table] WHERE [condition]

Returns:: The number of deleted records
Throws:: DataAccessException - if something went wrong executing the query

Interface DSLContext

Method Summary

Methods inherited from interface org.jooq.Scope

Method Detail

close

map

map

parser

parsingConnection

parsingDataSource

diagnosticsConnection

diagnosticsDataSource

meta

meta

meta

meta

meta

meta

meta

informationSchema

informationSchema

informationSchema

informationSchema

informationSchema

informationSchema

explain

transactionResult

transactionResult

transaction

transaction

transactionResultAsync

transactionAsync

transactionResultAsync

transactionAsync

connectionResult

connection

mockResult

mock

renderContext

render

renderNamedParams

renderNamedOrInlinedParams

renderInlined

extractBindValues

extractParams

extractParam

bindContext

bind

attach

attach

loadInto

queries

queries

begin

begin

statements

statements

query

query

query

query

fetch

fetch

fetch

fetch

fetchLazy

fetchLazy

fetchLazy

fetchLazy

fetchAsync

fetchAsync

fetchAsync

fetchAsync

fetchAsync

fetchAsync

fetchAsync

fetchAsync

fetchStream

fetchStream

fetchStream