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

All Implemented Interfaces:

java.io.Serializable, java.lang.AutoCloseable, DSLContext, Scope
```
public class DefaultDSLContext
extends java.lang.Object
implements DSLContext, java.io.Serializable
```
A default implementation for DSLContext.
You may use this as a base implementation for custom DSLContext subtypes preventing potential API breakage when upgrading jOOQ, or to delegate DSL method calls to your custom implementations.

Author:

Lukas Eder

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor	Description
`DefaultDSLContext(java.sql.Connection connection, SQLDialect dialect)`
`DefaultDSLContext(java.sql.Connection connection, SQLDialect dialect, Settings settings)`
`DefaultDSLContext(javax.sql.DataSource datasource, SQLDialect dialect)`
`DefaultDSLContext(javax.sql.DataSource datasource, SQLDialect dialect, Settings settings)`
`DefaultDSLContext(Configuration configuration)`
`DefaultDSLContext(ConnectionProvider connectionProvider, SQLDialect dialect)`
`DefaultDSLContext(ConnectionProvider connectionProvider, SQLDialect dialect, Settings settings)`
`DefaultDSLContext(SQLDialect dialect)`
`DefaultDSLContext(SQLDialect dialect, Settings settings)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`AlterIndexOnStep`	`alterIndex(java.lang.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(java.lang.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(java.lang.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(java.lang.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<java.math.BigInteger>`	`alterSequence(java.lang.String sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterSequenceStep<java.math.BigInteger>`	`alterSequence(Name sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`<T extends java.lang.Number> AlterSequenceStep<T>`	`alterSequence(Sequence<T> sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterSequenceStep<java.math.BigInteger>`	`alterSequenceIfExists(java.lang.String sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterSequenceStep<java.math.BigInteger>`	`alterSequenceIfExists(Name sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`<T extends java.lang.Number> AlterSequenceStep<T>`	`alterSequenceIfExists(Sequence<T> sequence)`	Create a new DSL `ALTER SEQUENCE` statement.
`AlterTableStep`	`alterTable(java.lang.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(java.lang.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(java.lang.String table)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterView(Name table)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterView(Table<?> table)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterViewIfExists(java.lang.String table)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterViewIfExists(Name table)`	Create a new DSL `ALTER VIEW` statement.
`AlterViewStep`	`alterViewIfExists(Table<?> table)`	Create a new DSL `ALTER VIEW` statement.
`void`	`attach(java.util.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(java.lang.String sql)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batch(java.lang.String... queries)`	Create a batch statement to execute a set of queries in batch mode (without bind values).
`Batch`	`batch(java.lang.String sql, java.lang.Object[]... bindings)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batch(java.util.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, java.lang.Object[]... bindings)`	Create a batch statement to execute a set of queries in batch mode (with bind values).
`Batch`	`batchDelete(java.util.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(java.util.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(java.util.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(java.util.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(java.util.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, java.sql.PreparedStatement stmt)`	Deprecated.
`BindContext`	`bindContext(java.sql.PreparedStatement stmt)`	Get a new `BindContext` for the context of this `DSLContext`.
`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(java.lang.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(java.lang.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.
`Configuration`	`configuration()`	The configuration of the current scope.
`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(java.lang.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(java.lang.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(java.lang.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(java.lang.String view, java.lang.String... fields)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(java.lang.String view, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends java.lang.String> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(java.lang.String view, java.util.function.Function<? super Field<?>,? extends java.lang.String> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Name view, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Name view, java.util.function.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, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE OR REPLACE VIEW` statement.
`CreateViewAsStep<Record>`	`createOrReplaceView(Table<?> view, java.util.function.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.String view, java.lang.String... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(java.lang.String view, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends java.lang.String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(java.lang.String view, java.util.function.Function<? super Field<?>,? extends java.lang.String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Name view, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Name view, java.util.function.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, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createView(Table<?> view, java.util.function.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(java.lang.String view, java.lang.String... fields)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(java.lang.String view, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends java.lang.String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(java.lang.String view, java.util.function.Function<? super Field<?>,? extends java.lang.String> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Name view, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends Name> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Name view, java.util.function.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, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends Field<?>> fieldNameFunction)`	Create a new DSL `CREATE VIEW` statement.
`CreateViewAsStep<Record>`	`createViewIfNotExists(Table<?> view, java.util.function.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.
`java.math.BigInteger`	`currval(java.lang.String sequence)`	Convenience method to fetch the CURRVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`java.math.BigInteger`	`currval(Name sequence)`	Convenience method to fetch the CURRVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`<T extends java.lang.Number> T`	`currval(Sequence<T> sequence)`	Convenience method to fetch the CURRVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`java.util.Map<java.lang.Object,java.lang.Object>`	`data()`	Get all custom data from this `Scope`.
`java.lang.Object`	`data(java.lang.Object key)`	Get some custom data from this `Scope`.
`java.lang.Object`	`data(java.lang.Object key, java.lang.Object value)`	Set some custom data to this `Scope`.
`Queries`	`ddl(java.util.Collection<? extends Table<?>> tables)`	Generate the complete creation script for tables.
`Queries`	`ddl(java.util.Collection<? extends Table<?>> tables, DDLExportConfiguration exportConfiguration)`	Generate the complete creation script for tables.
`Queries`	`ddl(java.util.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 catalog, DDLExportConfiguration exportConfiguration)`	Generate a partial creation script for the entire catalog.
`Queries`	`ddl(Catalog catalog, 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 exportConfiguration)`	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... tables)`	Generate the complete creation script for tables.
`Queries`	`ddl(Table[] tables, DDLExportConfiguration exportConfiguration)`	Generate the complete creation script for tables.
`Queries`	`ddl(Table[] tables, DDLFlag... flags)`	Generate the complete creation script for tables.
`Queries`	`ddl(Table<?> table)`	Generate the complete creation script for a table.
`Queries`	`ddl(Table<?> table, DDLExportConfiguration exportConfiguration)`	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`
`java.sql.Connection`	`diagnosticsConnection()`	A JDBC connection that proxies the underlying connection to run the jOOQ Diagnostics Pack on executed queries.
`javax.sql.DataSource`	`diagnosticsDataSource()`	A JDBC connection that proxies the underlying connection to run the jOOQ Diagnostics Pack on executed queries.
`SQLDialect`	`dialect()`	The `SQLDialect` wrapped by this context.
`DropIndexOnStep`	`dropIndex(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.String type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropType(java.lang.String... type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropType(java.util.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(java.lang.String type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(java.lang.String... type)`	Create a new DSL `DROP TYPE` statement.
`DropTypeStep`	`dropTypeIfExists(java.util.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(java.lang.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(java.lang.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.
`DSLContext`	`dsl()`	Wrap the `Scope.configuration()` in a `DSLContext`, providing access to the configuration-contextual DSL to construct executable queries.
`int`	`execute(java.lang.String sql)`	Execute a query holding plain SQL.
`int`	`execute(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`int`	`execute(java.lang.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.
`java.util.List<java.lang.Object>`	`extractBindValues(QueryPart part)`	Retrieve the bind values that will be bound by a given `QueryPart`.
`Param<?>`	`extractParam(QueryPart part, java.lang.String name)`	Get a named parameter from a `QueryPart`, provided its name.
`java.util.Map<java.lang.String,Param<?>>`	`extractParams(QueryPart part)`	Get a `Map` of named parameters.
`SQLDialect`	`family()`	The `SQLDialect.family()` wrapped by this context.
`Result<Record>`	`fetch(java.lang.String sql)`	Execute a new query holding plain SQL.
`Result<Record>`	`fetch(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`Result<Record>`	`fetch(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Result<Record>`	`fetch(java.sql.ResultSet rs)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`Result<Record>`	`fetch(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`Result<Record>`	`fetch(java.sql.ResultSet rs, DataType<?>... types)`	Fetch all data from a JDBC `ResultSet` and transform it to a jOOQ `Result`.
`Result<Record>`	`fetch(java.sql.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, java.util.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, java.util.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
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.lang.String sql)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.lang.String sql, java.lang.Object... bindings)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.lang.String sql, QueryPart... parts)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.sql.ResultSet rs)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.sql.ResultSet rs, DataType<?>... types)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.sql.ResultSet rs, Field<?>... fields)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.lang.String sql)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.lang.String sql, java.lang.Object... bindings)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.lang.String sql, QueryPart... parts)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.sql.ResultSet rs)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.sql.ResultSet rs, java.lang.Class<?>... types)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.sql.ResultSet rs, DataType<?>... types)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.Executor executor, java.sql.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> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(java.util.concurrent.Executor executor, ResultQuery<R> query)`	Fetch results in a new `CompletionStage` that is asynchronously completed by a task running in the given executor.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(java.util.concurrent.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> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(java.util.concurrent.Executor executor, Table<R> table)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(java.util.concurrent.Executor executor, Table<R> table, java.util.Collection<? extends Condition> conditions)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(java.util.concurrent.Executor executor, Table<R> table, Condition condition)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(java.util.concurrent.Executor executor, Table<R> table, Condition... conditions)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(ResultQuery<R> query)`	Fetch results in a new `CompletionStage`.
`java.util.concurrent.CompletionStage<Result<Record>>`	`fetchAsync(SQL sql)`	Fetch results in a new `CompletionStage`.
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(Table<R> table)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(Table<R> table, java.util.Collection<? extends Condition> conditions)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(Table<R> table, Condition condition)`	Execute and return all records asynchronously for
`<R extends Record> java.util.concurrent.CompletionStage<Result<R>>`	`fetchAsync(Table<R> table, Condition... conditions)`	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, java.util.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, java.util.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(java.lang.String string)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromCSV(java.lang.String string, boolean header)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromCSV(java.lang.String string, boolean header, char delimiter)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromCSV(java.lang.String string, char delimiter)`	Fetch all data from a CSV string.
`Result<Record>`	`fetchFromHTML(java.lang.String string)`	Convert an HTML table into a jOOQ `Result`.
`Result<Record>`	`fetchFromJSON(java.lang.String string)`	Fetch all data from a JSON string.
`Result<Record>`	`fetchFromStringData(java.lang.String[]... strings)`	Fetch all data from a list of strings.
`Result<Record>`	`fetchFromStringData(java.util.List<java.lang.String[]> strings)`	Fetch all data from a list of strings.
`Result<Record>`	`fetchFromStringData(java.util.List<java.lang.String[]> strings, boolean header)`	Fetch all data from a list of strings.
`Result<Record>`	`fetchFromTXT(java.lang.String string)`	Fetch all data from a formatted string.
`Result<Record>`	`fetchFromTXT(java.lang.String string, java.lang.String nullLiteral)`	Fetch all data from a formatted string.
`Result<Record>`	`fetchFromXML(java.lang.String string)`	Fetch all data from an XML string.
`Cursor<Record>`	`fetchLazy(java.lang.String sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Cursor<Record>`	`fetchLazy(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Cursor<Record>`	`fetchLazy(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`Cursor<Record>`	`fetchLazy(java.sql.ResultSet rs)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`Cursor<Record>`	`fetchLazy(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`Cursor<Record>`	`fetchLazy(java.sql.ResultSet rs, DataType<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Cursor`.
`Cursor<Record>`	`fetchLazy(java.sql.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, java.util.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(java.lang.String sql)`	Execute a new query holding plain SQL, possibly returning several result sets.
`Results`	`fetchMany(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL, possibly returning several result sets.
`Results`	`fetchMany(java.lang.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(java.lang.String sql)`	Execute a new query holding plain SQL.
`Record`	`fetchOne(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`Record`	`fetchOne(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Record`	`fetchOne(java.sql.ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchOne(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchOne(java.sql.ResultSet rs, DataType<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchOne(java.sql.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, java.util.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
`java.util.Optional<Record>`	`fetchOptional(java.lang.String sql)`	Execute a new query holding plain SQL.
`java.util.Optional<Record>`	`fetchOptional(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`java.util.Optional<Record>`	`fetchOptional(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`java.util.Optional<Record>`	`fetchOptional(java.sql.ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`java.util.Optional<Record>`	`fetchOptional(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`java.util.Optional<Record>`	`fetchOptional(java.sql.ResultSet rs, DataType<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`java.util.Optional<Record>`	`fetchOptional(java.sql.ResultSet rs, Field<?>... fields)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`<R extends Record> java.util.Optional<R>`	`fetchOptional(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a record.
`java.util.Optional<Record>`	`fetchOptional(SQL sql)`	Execute a new query holding plain SQL.
`<R extends Record> java.util.Optional<R>`	`fetchOptional(Table<R> table)`	Execute and return zero or one record for
`<R extends Record> java.util.Optional<R>`	`fetchOptional(Table<R> table, java.util.Collection<? extends Condition> conditions)`	Execute and return zero or one record for
`<R extends Record> java.util.Optional<R>`	`fetchOptional(Table<R> table, Condition condition)`	Execute and return zero or one record for
`<R extends Record> java.util.Optional<R>`	`fetchOptional(Table<R> table, Condition... conditions)`	Execute and return zero or one record for
`java.util.Optional<?>`	`fetchOptionalValue(java.lang.String sql)`	Execute a new query holding plain SQL.
`java.util.Optional<?>`	`fetchOptionalValue(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`java.util.Optional<?>`	`fetchOptionalValue(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`java.util.Optional<?>`	`fetchOptionalValue(java.sql.ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> java.util.Optional<T>`	`fetchOptionalValue(java.sql.ResultSet rs, java.lang.Class<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> java.util.Optional<T>`	`fetchOptionalValue(java.sql.ResultSet rs, DataType<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> java.util.Optional<T>`	`fetchOptionalValue(java.sql.ResultSet rs, Field<T> field)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T,R extends Record1<T>> java.util.Optional<T>`	`fetchOptionalValue(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`java.util.Optional<?>`	`fetchOptionalValue(SQL sql)`	Execute a new query holding plain SQL.
`<T> java.util.Optional<T>`	`fetchOptionalValue(TableField<?,T> field)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a single value.
`Record`	`fetchSingle(java.lang.String sql)`	Execute a new query holding plain SQL.
`Record`	`fetchSingle(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`Record`	`fetchSingle(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`Record`	`fetchSingle(java.sql.ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(java.sql.ResultSet rs, DataType<?>... types)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(java.sql.ResultSet rs, Field<?>... fields)`	Fetch a record from a JDBC `ResultSet` and transform it to a jOOQ `Record`.
`Record`	`fetchSingle(java.util.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, java.util.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
`java.util.stream.Stream<Record>`	`fetchStream(java.lang.String sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`java.util.stream.Stream<Record>`	`fetchStream(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`java.util.stream.Stream<Record>`	`fetchStream(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`java.util.stream.Stream<Record>`	`fetchStream(java.sql.ResultSet rs)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`java.util.stream.Stream<Record>`	`fetchStream(java.sql.ResultSet rs, java.lang.Class<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`java.util.stream.Stream<Record>`	`fetchStream(java.sql.ResultSet rs, DataType<?>... types)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`java.util.stream.Stream<Record>`	`fetchStream(java.sql.ResultSet rs, Field<?>... fields)`	Wrap a JDBC `ResultSet` into a jOOQ `Stream`.
`<R extends Record> java.util.stream.Stream<R>`	`fetchStream(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return a stream.
`java.util.stream.Stream<Record>`	`fetchStream(SQL sql)`	Execute a new query holding plain SQL and "lazily" return the generated result.
`<R extends Record> java.util.stream.Stream<R>`	`fetchStream(Table<R> table)`	Execute and return all records lazily for
`<R extends Record> java.util.stream.Stream<R>`	`fetchStream(Table<R> table, java.util.Collection<? extends Condition> conditions)`	Execute and return all records lazily for
`<R extends Record> java.util.stream.Stream<R>`	`fetchStream(Table<R> table, Condition condition)`	Execute and return all records lazily for
`<R extends Record> java.util.stream.Stream<R>`	`fetchStream(Table<R> table, Condition... conditions)`	Execute and return all records lazily for
`java.lang.Object`	`fetchValue(java.lang.String sql)`	Execute a new query holding plain SQL.
`java.lang.Object`	`fetchValue(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`java.lang.Object`	`fetchValue(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`java.lang.Object`	`fetchValue(java.sql.ResultSet rs)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(java.sql.ResultSet rs, java.lang.Class<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(java.sql.ResultSet rs, DataType<T> type)`	Fetch a record from a JDBC `ResultSet` and return the only contained value.
`<T> T`	`fetchValue(java.sql.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.
`java.lang.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.
`java.util.List<?>`	`fetchValues(java.lang.String sql)`	Execute a new query holding plain SQL.
`java.util.List<?>`	`fetchValues(java.lang.String sql, java.lang.Object... bindings)`	Execute a new query holding plain SQL.
`java.util.List<?>`	`fetchValues(java.lang.String sql, QueryPart... parts)`	Execute a new query holding plain SQL.
`java.util.List<?>`	`fetchValues(java.sql.ResultSet rs)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T> java.util.List<T>`	`fetchValues(java.sql.ResultSet rs, java.lang.Class<T> type)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T> java.util.List<T>`	`fetchValues(java.sql.ResultSet rs, DataType<T> type)`	Fetch a result from a JDBC `ResultSet` and return the only contained column's values.
`<T> java.util.List<T>`	`fetchValues(java.sql.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>> java.util.List<T>`	`fetchValues(ResultQuery<R> query)`	Execute a `ResultQuery` in the context of this `DSLContext` and return all values for the only column.
`java.util.List<?>`	`fetchValues(SQL sql)`	Execute a new query holding plain SQL.
`<T> java.util.List<T>`	`fetchValues(Table<? extends Record1<T>> table)`	Fetch all values from a single column table.
`<T> java.util.List<T>`	`fetchValues(TableField<?,T> field)`	Fetch all values in a given `Table`'s `TableField`.
`GrantOnStep`	`grant(java.util.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<?>... tables)`	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, java.util.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`
`java.math.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, java.util.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(java.sql.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(java.util.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, java.lang.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(java.util.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`.
`java.math.BigInteger`	`nextval(java.lang.String sequence)`	Convenience method to fetch the NEXTVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`java.math.BigInteger`	`nextval(Name sequence)`	Convenience method to fetch the NEXTVAL for a sequence directly from this `DSLContext`'s underlying JDBC `Connection`.
`<T extends java.lang.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.
`java.sql.Connection`	`parsingConnection()`	A JDBC connection that runs each statement through the `DSLContext.parser()` first, prior to re-generating and running the SQL.
`javax.sql.DataSource`	`parsingDataSource()`	A JDBC data source that runs each statement through the `DSLContext.parser()` first, prior to re-generating and running the SQL.
`Queries`	`queries(java.util.Collection<? extends Query> queries)`	Wrap a collection of queries.
`Queries`	`queries(Query... queries)`	Wrap a collection of queries.
`RowCountQuery`	`query(java.lang.String sql)`	Create a new query holding plain SQL.
`RowCountQuery`	`query(java.lang.String sql, java.lang.Object... bindings)`	Create a new query holding plain SQL.
`RowCountQuery`	`query(java.lang.String sql, QueryPart... parts)`	Create a new query holding plain SQL.
`RowCountQuery`	`query(SQL sql)`	Create a new query holding plain SQL.
`java.lang.String`	`render(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`.
`RenderContext`	`renderContext()`	Get a new `RenderContext` for the context of this `DSLContext`.
`java.lang.String`	`renderInlined(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`, inlining all bind variables.
`java.lang.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.
`java.lang.String`	`renderNamedParams(QueryPart part)`	Render a QueryPart in the context of this `DSLContext`, rendering bind variables as named parameters.
`ResultQuery<Record>`	`resultQuery(java.lang.String sql)`	Create a new query holding plain SQL.
`ResultQuery<Record>`	`resultQuery(java.lang.String sql, java.lang.Object... bindings)`	Create a new query holding plain SQL.
`ResultQuery<Record>`	`resultQuery(java.lang.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(java.util.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(java.util.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(java.util.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<java.lang.Integer>>`	`selectCount()`	Create a new DSL select statement for `COUNT(*)`.
`SelectSelectStep<Record>`	`selectDistinct(java.util.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(java.lang.String sql)`	Create a new DSL select statement.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(java.lang.String sql, java.lang.Object... bindings)`	Create a new DSL select statement.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(java.lang.String sql, QueryPart... parts)`	Create a new DSL select statement.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(Name table)`	Create a new DSL select statement.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(SQL sql)`	Create a new DSL select statement.
`<R extends Record> SelectWhereStep<R>`	`selectFrom(Table<R> table)`	Create a new DSL select statement.
`SelectSelectStep<Record1<java.lang.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<java.lang.Integer>>`	`selectZero()`	Create a new DSL select statement for a constant `0` literal.
`RowCountQuery`	`setCatalog(java.lang.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(java.lang.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.
`Settings`	`settings()`	The settings wrapped by this context.
`Block`	`statements(java.util.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 ..`
`java.lang.String`	`toString()`
`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()`.
`java.util.concurrent.CompletionStage<java.lang.Void>`	`transactionAsync(java.util.concurrent.Executor executor, TransactionalRunnable transactional)`	Run a `TransactionalRunnable` asynchronously.
`java.util.concurrent.CompletionStage<java.lang.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> java.util.concurrent.CompletionStage<T>`	`transactionResultAsync(java.util.concurrent.Executor executor, TransactionalCallable<T> transactional)`	Run a `TransactionalCallable` asynchronously.
`<T> java.util.concurrent.CompletionStage<T>`	`transactionResultAsync(TransactionalCallable<T> transactional)`	Run a `TransactionalCallable` asynchronously.
`TruncateIdentityStep<Record>`	`truncate(java.lang.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(java.lang.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(java.lang.String alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep1`	`with(java.lang.String alias, java.lang.String fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(java.lang.String alias, java.lang.String... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep2`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep3`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep4`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep5`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep6`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep7`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep8`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep9`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep10`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep11`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep12`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep13`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep14`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep15`	`with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep16`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep17`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep18`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep19`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep20`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19, java.lang.String fieldAlias20)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep21`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19, java.lang.String fieldAlias20, java.lang.String fieldAlias21)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep22`	with(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19, java.lang.String fieldAlias20, java.lang.String fieldAlias21, java.lang.String fieldAlias22)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(java.lang.String alias, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends java.lang.String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`with(java.lang.String alias, java.util.function.Function<? super Field<?>,? extends java.lang.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(java.lang.String alias)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep1`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(java.lang.String alias, java.lang.String... fieldAliases)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep2`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep3`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep4`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep5`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep6`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep7`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep8`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep9`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep10`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep11`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep12`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep13`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep14`	`withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep15`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep16`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep17`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep18`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep19`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep20`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19, java.lang.String fieldAlias20)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep21`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19, java.lang.String fieldAlias20, java.lang.String fieldAlias21)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep22`	withRecursive(java.lang.String alias, java.lang.String fieldAlias1, java.lang.String fieldAlias2, java.lang.String fieldAlias3, java.lang.String fieldAlias4, java.lang.String fieldAlias5, java.lang.String fieldAlias6, java.lang.String fieldAlias7, java.lang.String fieldAlias8, java.lang.String fieldAlias9, java.lang.String fieldAlias10, java.lang.String fieldAlias11, java.lang.String fieldAlias12, java.lang.String fieldAlias13, java.lang.String fieldAlias14, java.lang.String fieldAlias15, java.lang.String fieldAlias16, java.lang.String fieldAlias17, java.lang.String fieldAlias18, java.lang.String fieldAlias19, java.lang.String fieldAlias20, java.lang.String fieldAlias21, java.lang.String fieldAlias22)	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(java.lang.String alias, java.util.function.BiFunction<? super Field<?>,? super java.lang.Integer,? extends java.lang.String> fieldNameFunction)`	Create a `WITH` clause to supply subsequent `SELECT`, `UPDATE`, `INSERT`, `DELETE`, and `MERGE` statements with `CommonTableExpression`s.
`WithAsStep`	`withRecursive(java.lang.String alias, java.util.function.Function<? super Field<?>,? extends java.lang.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 class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

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

Constructor Detail

DefaultDSLContext

public DefaultDSLContext(SQLDialect dialect)

DefaultDSLContext

public DefaultDSLContext(SQLDialect dialect,
                         Settings settings)

DefaultDSLContext

public DefaultDSLContext(java.sql.Connection connection,
                         SQLDialect dialect)

DefaultDSLContext

public DefaultDSLContext(java.sql.Connection connection,
                         SQLDialect dialect,
                         Settings settings)

DefaultDSLContext

public DefaultDSLContext(javax.sql.DataSource datasource,
                         SQLDialect dialect)

DefaultDSLContext

public DefaultDSLContext(javax.sql.DataSource datasource,
                         SQLDialect dialect,
                         Settings settings)

DefaultDSLContext

public DefaultDSLContext(ConnectionProvider connectionProvider,
                         SQLDialect dialect)

DefaultDSLContext

public DefaultDSLContext(ConnectionProvider connectionProvider,
                         SQLDialect dialect,
                         Settings settings)

DefaultDSLContext

public DefaultDSLContext(Configuration configuration)

Method Detail

close
```
public void close()
```
Description copied from interface: DSLContext

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 DSLContext.close() method.

Specified by:

close in interface java.lang.AutoCloseable

Specified by:

close in interface DSLContext

map
```
public Schema map(Schema schema)
```
Description copied from interface: DSLContext

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.

Specified by:

map in interface DSLContext

Parameters:

schema - A schema

Returns:

The mapped schema

map
```
public <R extends Record> Table<R> map(Table<R> table)
```
Description copied from interface: DSLContext

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.

Specified by:

map in interface DSLContext

Parameters:

table - A table

Returns:

The mapped table

parser
```
public Parser parser()
```
Description copied from interface: DSLContext

Access the parser API.
This is experimental functionality.

Specified by:

parser in interface DSLContext

parsingConnection
```
public java.sql.Connection parsingConnection()
```
Description copied from interface: DSLContext
A JDBC connection that runs each statement through the DSLContext.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.
Specified by:

parsingConnection in interface DSLContext

parsingDataSource
```
public javax.sql.DataSource parsingDataSource()
```
Description copied from interface: DSLContext

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

Specified by:

parsingDataSource in interface DSLContext

diagnosticsConnection
```
public java.sql.Connection diagnosticsConnection()
```
Description copied from interface: DSLContext

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

Specified by:

diagnosticsConnection in interface DSLContext

diagnosticsDataSource
```
public javax.sql.DataSource diagnosticsDataSource()
```
Description copied from interface: DSLContext

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

Specified by:

diagnosticsDataSource in interface DSLContext

meta
```
public Meta meta()
```
Description copied from interface: DSLContext

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.

Specified by:

meta in interface DSLContext

See Also:

DSLContext.meta(DatabaseMetaData)

meta
```
public Meta meta(java.sql.DatabaseMetaData meta)
```
Description copied from interface: DSLContext

Access the database meta data from an explicit JDBC DatabaseMetaData.

Specified by:

meta in interface DSLContext

meta
```
public Meta meta(Catalog... catalogs)
```
Description copied from interface: DSLContext

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

Specified by:

meta in interface DSLContext

meta
```
public Meta meta(Schema... schemas)
```
Description copied from interface: DSLContext

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

Specified by:

meta in interface DSLContext

meta
```
public Meta meta(Table<?>... tables)
```
Description copied from interface: DSLContext

Access the database meta data from explicit table information.
This will not connect to your database to get live meta information, unlike DSLContext.meta() and DSLContext.meta(DatabaseMetaData).

Specified by:

meta in interface DSLContext

meta
```
public Meta meta(InformationSchema schema)
```
Description copied from interface: DSLContext

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 DSLContext.meta() and DSLContext.meta(DatabaseMetaData).

Specified by:

meta in interface DSLContext

meta
```
public Meta meta(Source... scripts)
```
Description copied from interface: DSLContext

Access the database meta data for a database represented by a list of DDL scripts. The DDL scripts will be parsed using DSLContext.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 DSLContext.meta() and DSLContext.meta(DatabaseMetaData).
This method is for internal only. Do not reference directly.

Specified by:

meta in interface DSLContext

informationSchema
```
public InformationSchema informationSchema(Catalog catalog)
```
Description copied from interface: DSLContext

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.

Specified by:

informationSchema in interface DSLContext

informationSchema
```
public InformationSchema informationSchema(Catalog... catalogs)
```
Description copied from interface: DSLContext

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.

Specified by:

informationSchema in interface DSLContext

informationSchema
```
public InformationSchema informationSchema(Schema schema)
```
Description copied from interface: DSLContext

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.

Specified by:

informationSchema in interface DSLContext

informationSchema
```
public InformationSchema informationSchema(Schema... schemas)
```
Description copied from interface: DSLContext

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.

Specified by:

informationSchema in interface DSLContext

informationSchema
```
public InformationSchema informationSchema(Table<?> table)
```
Description copied from interface: DSLContext

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.

Specified by:

informationSchema in interface DSLContext

informationSchema
```
public InformationSchema informationSchema(Table<?>... tables)
```
Description copied from interface: DSLContext

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.

Specified by:

informationSchema in interface DSLContext

explain
```
public Explain explain(Query query)
```
Description copied from interface: DSLContext

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

Specified by:

explain in interface DSLContext

transactionResult
```
public <T> T transactionResult(ContextTransactionalCallable<T> transactional)
```
Description copied from interface: DSLContext

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.

Specified by:

transactionResult in interface DSLContext

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

transactionResult
```
public <T> T transactionResult(TransactionalCallable<T> transactional)
```
Description copied from interface: DSLContext

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.

Specified by:

transactionResult in interface DSLContext

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

transaction
```
public void transaction(ContextTransactionalRunnable transactional)
```
Description copied from interface: DSLContext

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.

Specified by:

transaction in interface DSLContext

Parameters:

transactional - The transactional code

transaction
```
public void transaction(TransactionalRunnable transactional)
```
Description copied from interface: DSLContext

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.

Specified by:

transaction in interface DSLContext

Parameters:

transactional - The transactional code

transactionAsync
```
public java.util.concurrent.CompletionStage<java.lang.Void> transactionAsync(TransactionalRunnable transactional)
```
Description copied from interface: DSLContext

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().

Specified by:

transactionAsync in interface DSLContext

Parameters:

transactional - The transactional code

transactionAsync
```
public java.util.concurrent.CompletionStage<java.lang.Void> transactionAsync(java.util.concurrent.Executor executor,
                                                                             TransactionalRunnable transactional)
```
Description copied from interface: DSLContext

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.

Specified by:

transactionAsync in interface DSLContext

transactional - The transactional code

transactionResultAsync
```
public <T> java.util.concurrent.CompletionStage<T> transactionResultAsync(TransactionalCallable<T> transactional)
```
Description copied from interface: DSLContext

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().

Specified by:

transactionResultAsync in interface DSLContext

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

transactionResultAsync
```
public <T> java.util.concurrent.CompletionStage<T> transactionResultAsync(java.util.concurrent.Executor executor,
                                                                          TransactionalCallable<T> transactional)
```
Description copied from interface: DSLContext

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.

Specified by:

transactionResultAsync in interface DSLContext

transactional - The transactional code

Returns:

The transactional outcome

connectionResult
```
public <T> T connectionResult(ConnectionCallable<T> callable)
```
Description copied from interface: DSLContext

Run a ConnectionCallable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.connectionProvider().

Specified by:

connectionResult in interface DSLContext

Parameters:

callable - The code running statements against the connection.

Returns:

The outcome of the callable

connection
```
public void connection(ConnectionRunnable runnable)
```
Description copied from interface: DSLContext

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

Specified by:

connection in interface DSLContext

Parameters:

runnable - The code running statements against the connection.

mockResult
```
public <T> T mockResult(MockDataProvider provider,
                        MockCallable<T> mockable)
```
Description copied from interface: DSLContext

Run a MockRunnable in the context of this DSLContext 's underlying Scope.configuration()'s, and of a MockDataProvider and return the mockable's outcome.

Specified by:

mockResult in interface DSLContext

mock
```
public void mock(MockDataProvider provider,
                 MockRunnable mockable)
```
Description copied from interface: DSLContext

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

Specified by:

mock in interface DSLContext

renderContext
```
public RenderContext renderContext()
```
Description copied from interface: DSLContext
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
Specified by:

renderContext in interface DSLContext

render
```
public java.lang.String render(QueryPart part)
```
Description copied from interface: DSLContext

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

Specified by:

render in interface DSLContext

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderNamedParams
```
public java.lang.String renderNamedParams(QueryPart part)
```
Description copied from interface: DSLContext

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)

Specified by:

renderNamedParams in interface DSLContext

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderNamedOrInlinedParams
```
public java.lang.String renderNamedOrInlinedParams(QueryPart part)
```
Description copied from interface: DSLContext

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)

Specified by:

renderNamedOrInlinedParams in interface DSLContext

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderInlined
```
public java.lang.String renderInlined(QueryPart part)
```
Description copied from interface: DSLContext

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

Specified by:

renderInlined in interface DSLContext

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

extractBindValues
```
public java.util.List<java.lang.Object> extractBindValues(QueryPart part)
```
Description copied from interface: DSLContext

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

Specified by:

extractBindValues in interface DSLContext

extractParams
```
public java.util.Map<java.lang.String,Param<?>> extractParams(QueryPart part)
```
Description copied from interface: DSLContext

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.

Specified by:

extractParams in interface DSLContext

See Also:

Param, DSL.param(String, Object)

extractParam
```
public Param<?> extractParam(QueryPart part,
                             java.lang.String name)
```
Description copied from interface: DSLContext

Get a named parameter from a QueryPart, provided its name.
Bind values created with DSL.val(Object) will have their bind index as name.

Specified by:

extractParam in interface DSLContext

See Also:

Param, DSL.param(String, Object)

bindContext
```
public BindContext bindContext(java.sql.PreparedStatement stmt)
```
Description copied from interface: DSLContext
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
Specified by:

bindContext in interface DSLContext

bind

@Deprecated
public int bind(QueryPart part,
                java.sql.PreparedStatement stmt)

Deprecated.

Specified by:: bind in interface DSLContext

attach
```
public void attach(Attachable... attachables)
```
Description copied from interface: DSLContext

Attach this DSLContext's underlying Scope.configuration() to some attachables.

Specified by:

attach in interface DSLContext

attach
```
public void attach(java.util.Collection<? extends Attachable> attachables)
```
Description copied from interface: DSLContext

Attach this DSLContext's underlying Scope.configuration() to some attachables.

Specified by:

attach in interface DSLContext

loadInto
```
public <R extends Record> LoaderOptionsStep<R> loadInto(Table<R> table)
```
Description copied from interface: DSLContext

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

Specified by:

loadInto in interface DSLContext

queries
```
public Queries queries(Query... queries)
```
Description copied from interface: DSLContext

Wrap a collection of queries.

Specified by:

queries in interface DSLContext

See Also:

DSL.queries(Query...)

queries
```
public Queries queries(java.util.Collection<? extends Query> queries)
```
Description copied from interface: DSLContext

Wrap a collection of queries.

Specified by:

queries in interface DSLContext

See Also:

DSL.queries(Collection)

begin
```
public Block begin(Statement... statements)
```
Description copied from interface: DSLContext

Wrap a collection of statements in an anonymous procedural block.

Specified by:

begin in interface DSLContext

See Also:

DSL.begin(Statement...)

begin
```
public Block begin(java.util.Collection<? extends Statement> statements)
```
Description copied from interface: DSLContext

Wrap a collection of statements in an anoymous procedural block.

Specified by:

begin in interface DSLContext

See Also:

DSL.begin(Collection)

statements
```
@Pro
public Block statements(Statement... statements)
```
Description copied from interface: DSLContext

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

Specified by:

statements in interface DSLContext

See Also:

DSL.statements(Statement...)

statements
```
@Pro
public Block statements(java.util.Collection<? extends Statement> statements)
```
Description copied from interface: DSLContext

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

Specified by:

statements in interface DSLContext

See Also:

DSL.statements(Collection)

query
```
public RowCountQuery query(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

query in interface DSLContext

Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query
```
public RowCountQuery query(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

query in interface DSLContext

Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query
```
public RowCountQuery query(java.lang.String sql,
                           java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

query in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

A query wrapping the plain SQL

See Also:

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

query
```
public RowCountQuery query(java.lang.String sql,
                           QueryPart... parts)
```
Description copied from interface: DSLContext
Create a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

query in interface DSLContext

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
```
public Result<Record> fetch(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetch in interface DSLContext

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetch
```
public Result<Record> fetch(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetch in interface DSLContext

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetch
```
public Result<Record> fetch(java.lang.String sql,
                            java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetch in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

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

See Also:

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

fetch
```
public Result<Record> fetch(java.lang.String sql,
                            QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetch in interface DSLContext

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.

See Also:

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

fetchLazy
```
public Cursor<Record> fetchLazy(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchLazy in interface DSLContext

Parameters:

sql - The SQL

Returns:

The cursor. This will never be null.

See Also:

SQL

fetchLazy
```
public Cursor<Record> fetchLazy(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchLazy in interface DSLContext

Parameters:

sql - The SQL

Returns:

The cursor. This will never be null.

See Also:

SQL

fetchLazy
```
public Cursor<Record> fetchLazy(java.lang.String sql,
                                java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchLazy in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The cursor. This will never be null.

See Also:

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

fetchLazy
```
public Cursor<Record> fetchLazy(java.lang.String sql,
                                QueryPart... parts)
```
Description copied from interface: DSLContext
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 DSLContext.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
Specified by:

fetchLazy in interface DSLContext

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.

See Also:

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

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchAsync in interface DSLContext

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchAsync in interface DSLContext

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.lang.String sql,
                                                                       java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.lang.String sql,
                                                                       QueryPart... parts)
```
Description copied from interface: DSLContext
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 DSLContext.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
Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchAsync in interface DSLContext

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchAsync in interface DSLContext

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.lang.String sql,
                                                                       java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.lang.String sql,
                                                                       QueryPart... parts)
```
Description copied from interface: DSLContext
Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
Unlike DSLContext.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
Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.stream.Stream<Record> fetchStream(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchStream in interface DSLContext

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchStream
```
public java.util.stream.Stream<Record> fetchStream(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchStream in interface DSLContext

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchStream
```
public java.util.stream.Stream<Record> fetchStream(java.lang.String sql,
                                                   java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchStream in interface DSLContext

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

See Also:

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

fetchStream
```
public java.util.stream.Stream<Record> fetchStream(java.lang.String sql,
                                                   QueryPart... parts)
```
Description copied from interface: DSLContext
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 DSLContext.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
Specified by:

fetchStream in interface DSLContext

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

See Also:

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

fetchMany
```
public Results fetchMany(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchMany in interface DSLContext

Parameters:

sql - The SQL

Returns:

The results. This will never be null.

See Also:

SQL

fetchMany
```
public Results fetchMany(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchMany in interface DSLContext

Parameters:

sql - The SQL

Returns:

The results. This will never be null.

See Also:

SQL

fetchMany
```
public Results fetchMany(java.lang.String sql,
                         java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchMany in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results. This will never be null.

See Also:

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

fetchMany
```
public Results fetchMany(java.lang.String sql,
                         QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL, possibly returning several result sets.
Unlike DSLContext.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
Specified by:

fetchMany in interface DSLContext

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.

See Also:

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

fetchOne
```
public Record fetchOne(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOne in interface DSLContext

Parameters:

sql - The SQL

Returns:

The record or null, if no record was found.

See Also:

SQL

fetchOne
```
public Record fetchOne(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOne in interface DSLContext

Parameters:

sql - The SQL

Returns:

The record or null, if no record was found.

See Also:

SQL

fetchOne
```
public Record fetchOne(java.lang.String sql,
                       java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOne in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The record or null, if no record was found.

See Also:

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

fetchOne
```
public Record fetchOne(java.lang.String sql,
                       QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetchOne in interface DSLContext

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.

See Also:

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

fetchSingle
```
public Record fetchSingle(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchSingle in interface DSLContext

Parameters:

sql - The SQL

Returns:

The record. This is never null.

See Also:

SQL

fetchSingle
```
public Record fetchSingle(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchSingle in interface DSLContext

Parameters:

sql - The SQL

Returns:

The record. This is never null.

See Also:

SQL

fetchSingle
```
public Record fetchSingle(java.lang.String sql,
                          java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchSingle in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The record. This is never null.

See Also:

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

fetchSingle
```
public Record fetchSingle(java.lang.String sql,
                          QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetchSingle in interface DSLContext

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.

See Also:

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

fetchOptional
```
public java.util.Optional<Record> fetchOptional(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOptional in interface DSLContext

Parameters:

sql - The SQL

Returns:

The results from the executed query

See Also:

SQL

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOptional in interface DSLContext

Parameters:

sql - The SQL

Returns:

The results from the executed query

See Also:

SQL

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.lang.String sql,
                                                java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOptional in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

See Also:

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

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.lang.String sql,
                                                QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetchOptional in interface DSLContext

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

See Also:

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

fetchValue
```
public java.lang.Object fetchValue(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchValue in interface DSLContext

Parameters:

sql - The SQL

Returns:

The value or null, if no record was found.

See Also:

SQL

fetchValue
```
public java.lang.Object fetchValue(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchValue in interface DSLContext

Parameters:

sql - The SQL

Returns:

The value or null, if no record was found.

See Also:

SQL

fetchValue
```
public java.lang.Object fetchValue(java.lang.String sql,
                                   java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchValue in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The value or null, if no record was found.

See Also:

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

fetchValue
```
public java.lang.Object fetchValue(java.lang.String sql,
                                   QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetchValue in interface DSLContext

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.

See Also:

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

fetchOptionalValue
```
public java.util.Optional<?> fetchOptionalValue(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

sql - The SQL

Returns:

The result value from the executed query

See Also:

SQL

fetchOptionalValue
```
public java.util.Optional<?> fetchOptionalValue(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

sql - The SQL

Returns:

The result value from the executed query

See Also:

SQL

fetchOptionalValue
```
public java.util.Optional<?> fetchOptionalValue(java.lang.String sql,
                                                java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

See Also:

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

fetchOptionalValue
```
public java.util.Optional<?> fetchOptionalValue(java.lang.String sql,
                                                QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetchOptionalValue in interface DSLContext

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

See Also:

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

fetchValues
```
public java.util.List<?> fetchValues(SQL sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchValues in interface DSLContext

Parameters:

sql - The SQL

Returns:

The values. This will never be null.

See Also:

SQL

fetchValues
```
public java.util.List<?> fetchValues(java.lang.String sql)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchValues in interface DSLContext

Parameters:

sql - The SQL

Returns:

The values. This will never be null.

See Also:

SQL

fetchValues
```
public java.util.List<?> fetchValues(java.lang.String sql,
                                     java.lang.Object... bindings)
```
Description copied from interface: DSLContext
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!
Specified by:

fetchValues in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The values. This will never be null.

See Also:

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

fetchValues
```
public java.util.List<?> fetchValues(java.lang.String sql,
                                     QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

fetchValues in interface DSLContext

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.

See Also:

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

execute
```
public int execute(SQL sql)
```
Description copied from interface: DSLContext

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!

Specified by:

execute in interface DSLContext

Parameters:

sql - The SQL

Returns:

The results from the executed query

See Also:

SQL

execute
```
public int execute(java.lang.String sql)
```
Description copied from interface: DSLContext

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!

Specified by:

execute in interface DSLContext

Parameters:

sql - The SQL

Returns:

The results from the executed query

See Also:

SQL

execute
```
public int execute(java.lang.String sql,
                   java.lang.Object... bindings)
```
Description copied from interface: DSLContext

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!

Specified by:

execute in interface DSLContext

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

See Also:

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

execute
```
public int execute(java.lang.String sql,
                   QueryPart... parts)
```
Description copied from interface: DSLContext
Execute a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

execute in interface DSLContext

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

See Also:

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

resultQuery

public ResultQuery<Record> resultQuery(SQL sql)

Description copied from interface: DSLContext

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!

Specified by:: resultQuery in interface DSLContext
Parameters:: sql - The SQL
Returns:: An executable query
See Also:: SQL

resultQuery

public ResultQuery<Record> resultQuery(java.lang.String sql)

Description copied from interface: DSLContext

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!

Specified by:: resultQuery in interface DSLContext
Parameters:: sql - The SQL
Returns:: An executable query
See Also:: SQL

resultQuery

public ResultQuery<Record> resultQuery(java.lang.String sql,
                                       java.lang.Object... bindings)

Description copied from interface: DSLContext

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!

Specified by:: resultQuery in interface DSLContext
Parameters:: sql - The SQL; bindings - The bindings
Returns:: A query wrapping the plain SQL
See Also:: SQL, DSL.sql(String, Object...)

resultQuery
```
public ResultQuery<Record> resultQuery(java.lang.String sql,
                                       QueryPart... parts)
```
Description copied from interface: DSLContext
Create a new query holding plain SQL.
Unlike DSLContext.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
Specified by:

resultQuery in interface DSLContext

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
```
public Result<Record> fetch(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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 DSLContext.fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.

Specified by:

fetch in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting jOOQ Result. This will never be null.

fetch
```
public Result<Record> fetch(java.sql.ResultSet rs,
                            Field<?>... fields)
```
Description copied from interface: DSLContext

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 DSLContext.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

Specified by:

fetch in interface DSLContext

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.

fetch
```
public Result<Record> fetch(java.sql.ResultSet rs,
                            DataType<?>... types)
```
Description copied from interface: DSLContext

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 DSLContext.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

Specified by:

fetch in interface DSLContext

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.

fetch
```
public Result<Record> fetch(java.sql.ResultSet rs,
                            java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

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 DSLContext.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

Specified by:

fetch in interface DSLContext

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.

fetchOne
```
public Record fetchOne(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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.

Specified by:

fetchOne in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The record or null, if no record was found.

fetchOne
```
public Record fetchOne(java.sql.ResultSet rs,
                       Field<?>... fields)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOne in interface DSLContext

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.

fetchOne
```
public Record fetchOne(java.sql.ResultSet rs,
                       DataType<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOne in interface DSLContext

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.

fetchOne
```
public Record fetchOne(java.sql.ResultSet rs,
                       java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOne in interface DSLContext

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.

fetchSingle
```
public Record fetchSingle(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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.

Specified by:

fetchSingle in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The record or null, if no record was found.

fetchSingle
```
public Record fetchSingle(java.sql.ResultSet rs,
                          Field<?>... fields)
```
Description copied from interface: DSLContext

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

Specified by:

fetchSingle in interface DSLContext

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.

fetchSingle
```
public Record fetchSingle(java.sql.ResultSet rs,
                          DataType<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchSingle in interface DSLContext

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.

fetchSingle
```
public Record fetchSingle(java.sql.ResultSet rs,
                          java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchSingle in interface DSLContext

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.

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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.

Specified by:

fetchOptional in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting jOOQ record

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.sql.ResultSet rs,
                                                Field<?>... fields)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOptional in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting jOOQ record

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.sql.ResultSet rs,
                                                DataType<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOptional in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ record

fetchOptional
```
public java.util.Optional<Record> fetchOptional(java.sql.ResultSet rs,
                                                java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOptional in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ record

fetchValue
```
public java.lang.Object fetchValue(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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.

Specified by:

fetchValue in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The value or null, if no record was found.

fetchValue
```
public <T> T fetchValue(java.sql.ResultSet rs,
                        Field<T> field)
```
Description copied from interface: DSLContext

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

Specified by:

fetchValue in interface DSLContext

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.

fetchValue
```
public <T> T fetchValue(java.sql.ResultSet rs,
                        DataType<T> type)
```
Description copied from interface: DSLContext

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

Specified by:

fetchValue in interface DSLContext

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.

fetchValue
```
public <T> T fetchValue(java.sql.ResultSet rs,
                        java.lang.Class<T> type)
```
Description copied from interface: DSLContext

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

Specified by:

fetchValue in interface DSLContext

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.

fetchOptionalValue
```
public java.util.Optional<?> fetchOptionalValue(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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.

Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting value

fetchOptionalValue
```
public <T> java.util.Optional<T> fetchOptionalValue(java.sql.ResultSet rs,
                                                    Field<T> field)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The resulting value

fetchOptionalValue
```
public <T> java.util.Optional<T> fetchOptionalValue(java.sql.ResultSet rs,
                                                    DataType<T> type)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The resulting value

fetchOptionalValue
```
public <T> java.util.Optional<T> fetchOptionalValue(java.sql.ResultSet rs,
                                                    java.lang.Class<T> type)
```
Description copied from interface: DSLContext

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

Specified by:

fetchOptionalValue in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The resulting value

fetchValues
```
public java.util.List<?> fetchValues(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

Fetch a result from a JDBC ResultSet and return the only contained column's values.

Specified by:

fetchValues in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The values. This will never be null.

fetchValues
```
public <T> java.util.List<T> fetchValues(java.sql.ResultSet rs,
                                         Field<T> field)
```
Description copied from interface: DSLContext

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

Specified by:

fetchValues in interface DSLContext

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.

fetchValues
```
public <T> java.util.List<T> fetchValues(java.sql.ResultSet rs,
                                         DataType<T> type)
```
Description copied from interface: DSLContext

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

Specified by:

fetchValues in interface DSLContext

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.

fetchValues
```
public <T> java.util.List<T> fetchValues(java.sql.ResultSet rs,
                                         java.lang.Class<T> type)
```
Description copied from interface: DSLContext

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

Specified by:

fetchValues in interface DSLContext

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.

fetchLazy
```
public Cursor<Record> fetchLazy(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

Wrap a JDBC ResultSet into a jOOQ Cursor.
Use DSLContext.fetch(ResultSet), to load the entire ResultSet into a jOOQ Result at once.

Specified by:

fetchLazy in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The cursor. This will never be null.

fetchLazy
```
public Cursor<Record> fetchLazy(java.sql.ResultSet rs,
                                Field<?>... fields)
```
Description copied from interface: DSLContext

Wrap a JDBC ResultSet into a jOOQ Cursor.
Use DSLContext.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

Specified by:

fetchLazy in interface DSLContext

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.

fetchLazy
```
public Cursor<Record> fetchLazy(java.sql.ResultSet rs,
                                DataType<?>... types)
```
Description copied from interface: DSLContext

Wrap a JDBC ResultSet into a jOOQ Cursor.
Use DSLContext.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

Specified by:

fetchLazy in interface DSLContext

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.

fetchLazy
```
public Cursor<Record> fetchLazy(java.sql.ResultSet rs,
                                java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

Wrap a JDBC ResultSet into a jOOQ Cursor.
Use DSLContext.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

Specified by:

fetchLazy in interface DSLContext

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.

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

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().

Specified by:

fetchAsync in interface DSLContext

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

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

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.sql.ResultSet rs,
                                                                       Field<?>... fields)
```
Description copied from interface: DSLContext

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

Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.sql.ResultSet rs,
                                                                       DataType<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.sql.ResultSet rs,
                                                                       java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.sql.ResultSet rs)
```
Description copied from interface: DSLContext

Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.

Specified by:

fetchAsync in interface DSLContext

rs - The JDBC ResultSet to fetch data from

Returns:

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

fetchAsync
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.sql.ResultSet rs,
                                                                       Field<?>... fields)
```
Description copied from interface: DSLContext

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

Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.sql.ResultSet rs,
                                                                       DataType<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchAsync in interface DSLContext

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
```
public java.util.concurrent.CompletionStage<Result<Record>> fetchAsync(java.util.concurrent.Executor executor,
                                                                       java.sql.ResultSet rs,
                                                                       java.lang.Class<?>... types)
```
Description copied from interface: DSLContext

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

Specified by:

fetchAsync in interface DSLContext

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 ne

Class DefaultDSLContext

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.jooq.Scope

Constructor Detail

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

DefaultDSLContext

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

transactionAsync

transactionAsync

transactionResultAsync

transactionResultAsync

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