Module org.jooq

Package org.jooq

Interface DSLContext

All Superinterfaces:

Scope

All Known Subinterfaces:

CloseableDSLContext

All Known Implementing Classes:

DefaultCloseableDSLContext, DefaultDSLContext

public interface DSLContext
extends Scope

A contextual DSL providing "attached" implementations to the org.jooq interfaces.

Apart from the DSL, this contextual DSL is the main entry point for client code, to access jOOQ classes and functionality that are related to Query execution. Unlike objects created through the DSL type, objects created from a DSLContext will be "attached" to the DSLContext's Scope.configuration(), such that they can be executed immediately in a fluent style. An example is given here:

 DSLContext create = DSL.using(connection, dialect);

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

 // The above is equivalent to this "non-fluent" style
 create.fetch(DSL.selectFrom(MY_TABLE).where(MY_TABLE.ID.eq(1)));
 

The DSL provides convenient constructors to create a Configuration, which will be shared among all Query objects thus created. Optionally, you can pass a reusable Configuration to the DSL.using(Configuration) constructor. Please consider thread-safety concerns documented in Configuration, should you want to reuse the same Configuration instance in various threads and / or transactions.

Author:

Lukas Eder

See Also:

DSL, Configuration

Method Summary

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

Methods inherited from interface org.jooq.Scope

configuration, data, data, data, dialect, dsl, family, settings

Method Detail

map

@Nullable
@Nullable Schema map(Schema schema)

Map a schema to another one.

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

Parameters:

schema - A schema

Returns:

The mapped schema

map

@Nullable
<R extends Record> @Nullable Table<R> map(Table<R> table)

Map a table to another one.

This will map a table onto another one, depending on configured table mapping in this DSLContext. If no applicable table mapping can be found, the table itself is returned.

Parameters:

table - A table

Returns:

The mapped table

parser

@NotNull
@NotNull Parser parser()

Access the parser API.

This is experimental functionality.

parsingConnection

@NotNull
@NotNull Connection parsingConnection()

A JDBC connection that runs each statement through the parser() first, prior to re-generating and running the SQL.

The resulting Connection wraps an underlying JDBC connection that has been obtained from ConnectionProvider.acquire() and must be released by calling Connection.close().

This is experimental functionality:

• While this works well for static Statement executions, bind variables and their position calculation might cause issues when the generated SQL output involves more complex SQL transformation. See also https://github.com/jOOQ/jOOQ/issues/5759.
• Batching statements is currently not supported. See also https://github.com/jOOQ/jOOQ/issues/5757.

parsingDataSource

@NotNull
@NotNull DataSource parsingDataSource()

A JDBC data source that runs each statement through the parser() first, prior to re-generating and running the SQL.

This simply wraps the parsingConnection() in a DataSource.

diagnosticsConnection

@NotNull
@NotNull Connection diagnosticsConnection()

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

This is experimental functionality.

diagnosticsDataSource

@NotNull
@NotNull DataSource diagnosticsDataSource()

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

This simply wraps the diagnosticsConnection() in a DataSource.

version

@Internal
@NotNull
@NotNull Version version(String id)

Initialise a Version.

This is EXPERIMENTAL functionality and subject to change in future jOOQ versions.

migrateTo

@Internal
@NotNull
@NotNull Migration migrateTo(Version to)

Create a migration from the currently installed version to a new version.

This is EXPERIMENTAL functionality and subject to change in future jOOQ versions.

meta

@NotNull
@NotNull Meta meta()

Access the database meta data.

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

See Also:

meta(DatabaseMetaData)

meta

@NotNull
@NotNull Meta meta(DatabaseMetaData meta)

Access the database meta data from an explicit JDBC DatabaseMetaData.

meta

@NotNull
@NotNull Meta meta(Catalog... catalogs)

Access the database meta data from explicit catalog information.

This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta

@NotNull
@NotNull Meta meta(Schema... schemas)

Access the database meta data from explicit schema information.

This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta

@NotNull
@NotNull Meta meta(Table<?>... tables)

Access the database meta data from explicit table information.

This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta

@NotNull
@NotNull Meta meta(InformationSchema schema)

Access the database meta data from an explicit JAXB-annotated meta model.

This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

meta

@NotNull
@NotNull Meta meta(String... sources)
            throws DataDefinitionException,
                   ParserException

Create meta data from a set of sources.

This is convenience for wrapping all argument Strings in Source. The same set of content types are supported as in meta(Source...).

Throws:

DataDefinitionException - if the sources do not produce consistent meta data.

ParserException - if there is a parser error parsing the sources.

meta

@NotNull
@NotNull Meta meta(Source... sources)
            throws DataDefinitionException,
                   ParserException

Create meta data from a set of sources.

This method creates a Meta representation from a set of source content, which can be any of:

• A set of DDL scripts, which will be parsed using parser().
• A set of XML files, which will be unmarshalled into InformationSchema objects.

This will not connect to your database to get live meta information, unlike meta() and meta(DatabaseMetaData).

Throws:

DataDefinitionException - if the sources do not produce consistent meta data.

ParserException - if there is a parser error parsing the sources.

meta

@NotNull
@NotNull Meta meta(Query... queries)
            throws DataDefinitionException

Create meta data from a set of DDL queries.

This works the same way as meta(Source...), without the need of parsing the DDL scripts.

Throws:

DataDefinitionException - if the sources do not produce consistent meta data.

informationSchema

@NotNull
@NotNull InformationSchema informationSchema(Catalog catalog)

Convenience method for Meta.informationSchema().

See Also:

meta(Catalog...), Meta.informationSchema()

informationSchema

@NotNull
@NotNull InformationSchema informationSchema(Catalog... catalogs)

Convenience method for Meta.informationSchema().

See Also:

meta(Catalog...), Meta.informationSchema()

informationSchema

@NotNull
@NotNull InformationSchema informationSchema(Schema schema)

Convenience method for Meta.informationSchema().

See Also:

meta(Schema...), Meta.informationSchema()

informationSchema

@NotNull
@NotNull InformationSchema informationSchema(Schema... schemas)

Convenience method for Meta.informationSchema().

See Also:

meta(Schema...), Meta.informationSchema()

informationSchema

@NotNull
@NotNull InformationSchema informationSchema(Table<?> table)

Convenience method for Meta.informationSchema().

See Also:

meta(Table...), Meta.informationSchema()

informationSchema

@NotNull
@NotNull InformationSchema informationSchema(Table<?>... table)

Convenience method for Meta.informationSchema().

See Also:

meta(Table...), Meta.informationSchema()

explain

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

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

transactionResult

<T> T transactionResult(TransactionalCallable<T> transactional)

Run a TransactionalCallable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and return the transactional's outcome.

The argument transactional code should not capture any scope but derive its Configuration from the TransactionalCallable.run(Configuration) argument in order to create new statements.

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

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

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

transactionResult

<T> T transactionResult(ContextTransactionalCallable<T> transactional)
                 throws ConfigurationException

Run a ContextTransactionalRunnable in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and return the transactional's outcome.

The argument transactional code may capture scope to derive its Configuration from the "context" in order to create new statements. This context can be provided, for instance, by ThreadLocalTransactionProvider automatically.

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

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

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

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

transaction

void transaction(TransactionalRunnable transactional)

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

The argument transactional code should not capture any scope but derive its Configuration from the TransactionalCallable.run(Configuration) argument in order to create new statements.

Parameters:

transactional - The transactional code

Throws:

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

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

transaction

void transaction(ContextTransactionalRunnable transactional)
          throws ConfigurationException

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

The argument transactional code may capture scope to derive its Configuration from the "context" in order to create new statements. This context can be provided, for instance, by ThreadLocalTransactionProvider automatically.

Parameters:

transactional - The transactional code

Throws:

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

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

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

transactionResultAsync

@NotNull
<T> @NotNull CompletionStage<T> transactionResultAsync(TransactionalCallable<T> transactional)
                                                throws ConfigurationException

Run a TransactionalCallable asynchronously.

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

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

transactionAsync

@NotNull
@NotNull CompletionStage<Void> transactionAsync(TransactionalRunnable transactional)
                                         throws ConfigurationException

Run a TransactionalRunnable asynchronously.

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

Parameters:

transactional - The transactional code

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

transactionResultAsync

@NotNull
<T> @NotNull CompletionStage<T> transactionResultAsync(Executor executor,
                                                       TransactionalCallable<T> transactional)
                                                throws ConfigurationException

Run a TransactionalCallable asynchronously.

The TransactionCallable is run in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and returns the transactional's outcome in a new CompletionStage that is asynchronously completed by a task run by a given Executor.

Parameters:

transactional - The transactional code

Returns:

The transactional outcome

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

transactionAsync

@NotNull
@NotNull CompletionStage<Void> transactionAsync(Executor executor,
                                                TransactionalRunnable transactional)
                                         throws ConfigurationException

Run a TransactionalRunnable asynchronously.

The TransactionRunnable is run in the context of this DSLContext's underlying Scope.configuration()'s Configuration.transactionProvider(), and returns the transactional's outcome in a new CompletionStage that is asynchronously completed by a task run by a given Executor.

Parameters:

transactional - The transactional code

Throws:

ConfigurationException - If this is run with a ThreadLocalTransactionProvider.

connectionResult

<T> T connectionResult(ConnectionCallable<T> callable)

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

Parameters:

callable - The code running statements against the connection.

Returns:

The outcome of the callable

connection

void connection(ConnectionRunnable runnable)

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

Parameters:

runnable - The code running statements against the connection.

mockResult

<T> T mockResult(MockDataProvider provider,
                 MockCallable<T> mockable)

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

mock

void mock(MockDataProvider provider,
          MockRunnable mockable)

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

renderContext

@Deprecated
@Internal
@NotNull
@NotNull RenderContext renderContext()

Deprecated.

- [#6280] - 3.10 - Do not reuse this method. It will be completely internal with jOOQ 4.0

Get a new RenderContext for the context of this DSLContext.

This will return an initialised render context as such:

• Context.castMode() == DEFAULT
• Context.declareFields() == false
• Context.declareTables() == false
• Context.format() == false
• Context.paramType() == ParamType.INDEXED
• Context.qualify() == true
• Context.subquery() == false

render

@NotNull
@NotNull String render(QueryPart part)

Render a QueryPart in the context of this DSLContext.

This is the same as calling renderContext().render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderNamedParams

@NotNull
@NotNull String renderNamedParams(QueryPart part)

Render a QueryPart in the context of this DSLContext, rendering bind variables as named parameters.

This is the same as calling renderContext().paramType(NAMED).render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderNamedOrInlinedParams

@NotNull
@NotNull String renderNamedOrInlinedParams(QueryPart part)

Render a QueryPart in the context of this DSLContext, rendering bind variables as named parameters, or inlined parameters if they have no name.

This is the same as calling renderContext().paramType(NAMED_OR_INLINED).render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

renderInlined

@NotNull
@NotNull String renderInlined(QueryPart part)

Render a QueryPart in the context of this DSLContext, inlining all bind variables.

This is the same as calling renderContext().inline(true).render(part)

Parameters:

part - The QueryPart to be rendered

Returns:

The rendered SQL

extractBindValues

@NotNull
@NotNull List<Object> extractBindValues(QueryPart part)

Retrieve the bind values that will be bound by a given QueryPart.

The returned List is immutable. To modify bind values, use extractParams(QueryPart) instead.

Unlike extractParams(QueryPart), which returns also inlined parameters, this returns only actual bind values that will render an actual bind value as a question mark "?"

extractParams

@NotNull
@NotNull Map<String,Param<?>> extractParams(QueryPart part)

Get a Map of named parameters.

The Map itself is immutable, but the Param elements allow for modifying bind values on an existing Query (or any other QueryPart).

Bind values created with DSL.val(Object) will have their bind index as name.

See Also:

Param, DSL.param(String, Object)

extractParam

@Nullable
@Nullable Param<?> extractParam(QueryPart part,
                                String name)

Get a named parameter from a QueryPart, provided its name.

Bind values created with DSL.val(Object) will have their bind index as name.

See Also:

Param, DSL.param(String, Object)

bindContext

@Deprecated
@Internal
@NotNull
@NotNull BindContext bindContext(PreparedStatement stmt)

Deprecated.

- [#6280] - 3.10 - Do not reuse this method. It will be completely internal with jOOQ 4.0

Get a new BindContext for the context of this DSLContext.

This will return an initialised bind context as such:

• Context.declareFields() == false
• Context.declareTables() == false

BindContext for JOOQ INTERNAL USE only. Avoid referencing it directly

bind

@Deprecated
int bind(QueryPart part,
         PreparedStatement stmt)

Deprecated.

- [#2662] - 3.2.0 - Do not reuse this method. It will be removed with jOOQ 4.0

attach

void attach(Attachable... attachables)

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

attach

void attach(Collection<? extends Attachable> attachables)

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

loadInto

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

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

queries

@NotNull
@Support
@NotNull Queries queries(Query... queries)

Wrap a collection of queries.

See Also:

DSL.queries(Query...)

queries

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

Wrap a collection of queries.

See Also:

DSL.queries(Collection)

begin

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

Wrap a collection of statements in an anonymous procedural block.

See Also:

DSL.begin(Statement...)

begin

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

Wrap a collection of statements in an anoymous procedural block.

See Also:

DSL.begin(Collection)

statements

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

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

See Also:

DSL.statements(Statement...)

statements

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

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

See Also:

DSL.statements(Collection)

query

@NotNull
@Support
@PlainSQL
@NotNull RowCountQuery query(SQL sql)

Create a new query holding plain SQL. There must not be any binding variables contained in the SQL.

Example:

 String sql = "SET SCHEMA 'abc'";

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

Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query

@NotNull
@Support
@PlainSQL
@NotNull RowCountQuery query(String sql)

Create a new query holding plain SQL. There must not be any binding variables contained in the SQL.

Example:

 String sql = "SET SCHEMA 'abc'";

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

Parameters:

sql - The SQL

Returns:

A query wrapping the plain SQL

See Also:

SQL

query

@NotNull
@Support
@PlainSQL
@NotNull RowCountQuery query(String sql,
                             Object... bindings)

Create a new query holding plain SQL. There must be as many bind variables contained in the SQL, as passed in the bindings parameter.

Example:

 String sql = "SET SCHEMA 'abc'";

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

A query wrapping the plain SQL

See Also:

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

query

@NotNull
@Support
@PlainSQL
@NotNull RowCountQuery query(String sql,
                             QueryPart... parts)

Create a new query holding plain SQL.

Unlike query(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 query("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will render this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

A query wrapping the plain SQL

See Also:

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

fetch

@NotNull
@Support
@PlainSQL
@NotNull Result<Record> fetch(SQL sql)
                       throws DataAccessException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetch

@NotNull
@Support
@PlainSQL
@NotNull Result<Record> fetch(String sql)
                       throws DataAccessException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetch

@NotNull
@Support
@PlainSQL
@NotNull Result<Record> fetch(String sql,
                              Object... bindings)
                       throws DataAccessException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetch

@NotNull
@Support
@PlainSQL
@NotNull Result<Record> fetch(String sql,
                              QueryPart... parts)
                       throws DataAccessException

Execute a new query holding plain SQL.

Unlike fetch(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetch("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchLazy

@NotNull
@Support
@PlainSQL
@NotNull Cursor<Record> fetchLazy(SQL sql)
                           throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchLazy

@NotNull
@Support
@PlainSQL
@NotNull Cursor<Record> fetchLazy(String sql)
                           throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchLazy

@NotNull
@Support
@PlainSQL
@NotNull Cursor<Record> fetchLazy(String sql,
                                  Object... bindings)
                           throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

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

The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchLazy

@NotNull
@Support
@PlainSQL
@NotNull Cursor<Record> fetchLazy(String sql,
                                  QueryPart... parts)
                           throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Unlike fetchLazy(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(SQL sql)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(String sql)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(String sql,
                                                    Object... bindings)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

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

See Also:

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

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(String sql,
                                                    QueryPart... parts)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Unlike fetchLazy(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

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

See Also:

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

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    SQL sql)

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    String sql)

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

See Also:

SQL

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    String sql,
                                                    Object... bindings)

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

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

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

See Also:

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

fetchAsync

@NotNull
@Support
@PlainSQL
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    String sql,
                                                    QueryPart... parts)

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

Unlike fetchLazy(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

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

See Also:

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

fetchStream

@NotNull
@Support
@PlainSQL
@NotNull Stream<Record> fetchStream(SQL sql)
                             throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchStream

@NotNull
@Support
@PlainSQL
@NotNull Stream<Record> fetchStream(String sql)
                             throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchStream

@NotNull
@Support
@PlainSQL
@NotNull Stream<Record> fetchStream(String sql,
                                    Object... bindings)
                             throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

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

The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchStream

@NotNull
@Support
@PlainSQL
@NotNull Stream<Record> fetchStream(String sql,
                                    QueryPart... parts)
                             throws DataAccessException

Execute a new query holding plain SQL and "lazily" return the generated result.

The returned Stream holds a reference to the executed PreparedStatement and the associated ResultSet. Data can be fetched (or iterated over) lazily, fetching records from the ResultSet one by one.

Unlike fetchStream(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchLazy("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchMany

@NotNull
@Support
@PlainSQL
@NotNull Results fetchMany(SQL sql)
                    throws DataAccessException

Execute a new query holding plain SQL, possibly returning several result sets.

Example (Sybase ASE):

 String sql = "sp_help 'my_table'";

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

Parameters:

sql - The SQL

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchMany

@NotNull
@Support
@PlainSQL
@NotNull Results fetchMany(String sql)
                    throws DataAccessException

Execute a new query holding plain SQL, possibly returning several result sets.

Example (Sybase ASE):

 String sql = "sp_help 'my_table'";

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

Parameters:

sql - The SQL

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

fetchMany

@NotNull
@Support
@PlainSQL
@NotNull Results fetchMany(String sql,
                           Object... bindings)
                    throws DataAccessException

Execute a new query holding plain SQL, possibly returning several result sets.

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

Example (Sybase ASE):

 String sql = "sp_help 'my_table'";

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchMany

@NotNull
@Support
@PlainSQL
@NotNull Results fetchMany(String sql,
                           QueryPart... parts)
                    throws DataAccessException

Execute a new query holding plain SQL, possibly returning several result sets.

Unlike fetchMany(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchMany("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

fetchOne

@Nullable
@Support
@PlainSQL
@Nullable Record fetchOne(SQL sql)
                   throws DataAccessException,
                          TooManyRowsException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOne

@Nullable
@Support
@PlainSQL
@Nullable Record fetchOne(String sql)
                   throws DataAccessException,
                          TooManyRowsException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOne

@Nullable
@Support
@PlainSQL
@Nullable Record fetchOne(String sql,
                          Object... bindings)
                   throws DataAccessException,
                          TooManyRowsException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchOne

@Nullable
@Support
@PlainSQL
@Nullable Record fetchOne(String sql,
                          QueryPart... parts)
                   throws DataAccessException,
                          TooManyRowsException

Execute a new query holding plain SQL.

Unlike fetchOne(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchSingle

@NotNull
@Support
@PlainSQL
@NotNull Record fetchSingle(SQL sql)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchSingle

@NotNull
@Support
@PlainSQL
@NotNull Record fetchSingle(String sql)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchSingle

@NotNull
@Support
@PlainSQL
@NotNull Record fetchSingle(String sql,
                            Object... bindings)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchSingle

@NotNull
@Support
@PlainSQL
@NotNull Record fetchSingle(String sql,
                            QueryPart... parts)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Execute a new query holding plain SQL.

Unlike fetchOne(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchOptional

@NotNull
@Support
@PlainSQL
@NotNull Optional<Record> fetchOptional(SQL sql)
                                 throws DataAccessException,
                                        TooManyRowsException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOptional

@NotNull
@Support
@PlainSQL
@NotNull Optional<Record> fetchOptional(String sql)
                                 throws DataAccessException,
                                        TooManyRowsException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

SQL

fetchOptional

@NotNull
@Support
@PlainSQL
@NotNull Optional<Record> fetchOptional(String sql,
                                        Object... bindings)
                                 throws DataAccessException,
                                        TooManyRowsException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchOptional

@NotNull
@Support
@PlainSQL
@NotNull Optional<Record> fetchOptional(String sql,
                                        QueryPart... parts)
                                 throws DataAccessException,
                                        TooManyRowsException

Execute a new query holding plain SQL.

Unlike fetchOne(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

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

fetchValue

@Nullable
@Support
@PlainSQL
@Nullable Object fetchValue(SQL sql)
                     throws DataAccessException,
                            TooManyRowsException,
                            InvalidResultException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

SQL

fetchValue

@Nullable
@Support
@PlainSQL
@Nullable Object fetchValue(String sql)
                     throws DataAccessException,
                            TooManyRowsException,
                            InvalidResultException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

SQL

fetchValue

@Nullable
@Support
@PlainSQL
@Nullable Object fetchValue(String sql,
                            Object... bindings)
                     throws DataAccessException,
                            TooManyRowsException,
                            InvalidResultException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

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

fetchValue

@Nullable
@Support
@PlainSQL
@Nullable Object fetchValue(String sql,
                            QueryPart... parts)
                     throws DataAccessException,
                            TooManyRowsException,
                            InvalidResultException

Execute a new query holding plain SQL.

Unlike fetchValue(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

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

fetchOptionalValue

@NotNull
@Support
@PlainSQL
@NotNull Optional<?> fetchOptionalValue(SQL sql)
                                 throws DataAccessException,
                                        TooManyRowsException,
                                        InvalidResultException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The result value from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

SQL

fetchOptionalValue

@NotNull
@Support
@PlainSQL
@NotNull Optional<?> fetchOptionalValue(String sql)
                                 throws DataAccessException,
                                        TooManyRowsException,
                                        InvalidResultException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The result value from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

SQL

fetchOptionalValue

@NotNull
@Support
@PlainSQL
@NotNull Optional<?> fetchOptionalValue(String sql,
                                        Object... bindings)
                                 throws DataAccessException,
                                        TooManyRowsException,
                                        InvalidResultException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

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

fetchOptionalValue

@NotNull
@Support
@PlainSQL
@NotNull Optional<?> fetchOptionalValue(String sql,
                                        QueryPart... parts)
                                 throws DataAccessException,
                                        TooManyRowsException,
                                        InvalidResultException

Execute a new query holding plain SQL.

Unlike fetchValue(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

See Also:

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

fetchValues

@NotNull
@Support
@PlainSQL
@NotNull List<?> fetchValues(SQL sql)
                      throws DataAccessException,
                             InvalidResultException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

See Also:

SQL

fetchValues

@NotNull
@Support
@PlainSQL
@NotNull List<?> fetchValues(String sql)
                      throws DataAccessException,
                             InvalidResultException

Execute a new query holding plain SQL.

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

See Also:

SQL

fetchValues

@NotNull
@Support
@PlainSQL
@NotNull List<?> fetchValues(String sql,
                             Object... bindings)
                      throws DataAccessException,
                             InvalidResultException

Execute a new query holding plain SQL.

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

See Also:

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

fetchValues

@NotNull
@Support
@PlainSQL
@NotNull List<?> fetchValues(String sql,
                             QueryPart... parts)
                      throws DataAccessException,
                             InvalidResultException

Execute a new query holding plain SQL.

Unlike fetchValue(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

See Also:

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

execute

@Support
@PlainSQL
int execute(SQL sql)
     throws DataAccessException

Execute a query holding plain SQL.

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

Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

execute

@Support
@PlainSQL
int execute(String sql)
     throws DataAccessException

Execute a query holding plain SQL.

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

Parameters:

sql - The SQL

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

SQL

execute

@Support
@PlainSQL
int execute(String sql,
            Object... bindings)
     throws DataAccessException

Execute a new query holding plain SQL.

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

execute

@Support
@PlainSQL
int execute(String sql,
            QueryPart... parts)
     throws DataAccessException

Execute a new query holding plain SQL.

Unlike execute(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 execute("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will execute this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

The results from the executed query

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

resultQuery

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

Create a new query holding plain SQL.

There must not be any bind variables contained in the SQL

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

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

An executable query

See Also:

SQL

resultQuery

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

Create a new query holding plain SQL.

There must not be any bind variables contained in the SQL

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

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

Returns:

An executable query

See Also:

SQL

resultQuery

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

Create a new query holding plain SQL.

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

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

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

Example (Postgres):

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

Example (SQLite):

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

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

Parameters:

sql - The SQL

bindings - The bindings

Returns:

A query wrapping the plain SQL

See Also:

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

resultQuery

@NotNull
@Support
@PlainSQL
@NotNull ResultQuery<Record> resultQuery(String sql,
                                         QueryPart... parts)

Create a new query holding plain SQL.

Unlike resultQuery(String, Object...), the SQL passed to this method should not contain any bind variables. Instead, you can pass QueryPart objects to the method which will be rendered at indexed locations of your SQL string as such:

 // The following query
 resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));

 // Will render this SQL by default, using SQLDialect.ORACLE:
 select ?, 'test' from "DUAL"
 

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

Parameters:

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

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

Returns:

A query wrapping the plain SQL

See Also:

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

fetch

@NotNull
@Support
@NotNull Result<Record> fetch(ResultSet rs)
                       throws DataAccessException

Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.

After fetching all data, the JDBC ResultSet will be closed.

Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch

@NotNull
@Support
@NotNull Result<Record> fetch(ResultSet rs,
                              Field<?>... fields)
                       throws DataAccessException

Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.

After fetching all data, the JDBC ResultSet will be closed.

Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch

@NotNull
@Support
@NotNull Result<Record> fetch(ResultSet rs,
                              DataType<?>... types)
                       throws DataAccessException

Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.

After fetching all data, the JDBC ResultSet will be closed.

Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch

@NotNull
@Support
@NotNull Result<Record> fetch(ResultSet rs,
                              Class<?>... types)
                       throws DataAccessException

Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.

After fetching all data, the JDBC ResultSet will be closed.

Use fetchLazy(ResultSet), to fetch one Record at a time, instead of load the entire ResultSet into a jOOQ Result at once.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ Result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchOne

@Nullable
@Support
@Nullable Record fetchOne(ResultSet rs)
                   throws DataAccessException,
                          TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne

@Nullable
@Support
@Nullable Record fetchOne(ResultSet rs,
                          Field<?>... fields)
                   throws DataAccessException,
                          TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne

@Nullable
@Support
@Nullable Record fetchOne(ResultSet rs,
                          DataType<?>... types)
                   throws DataAccessException,
                          TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne

@Nullable
@Support
@Nullable Record fetchOne(ResultSet rs,
                          Class<?>... types)
                   throws DataAccessException,
                          TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
@NotNull Record fetchSingle(ResultSet rs)
                     throws DataAccessException,
                            TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
@NotNull Record fetchSingle(ResultSet rs,
                            Field<?>... fields)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
@NotNull Record fetchSingle(ResultSet rs,
                            DataType<?>... types)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
@NotNull Record fetchSingle(ResultSet rs,
                            Class<?>... types)
                     throws DataAccessException,
                            NoDataFoundException,
                            TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
@NotNull Optional<Record> fetchOptional(ResultSet rs)
                                 throws DataAccessException,
                                        NoDataFoundException,
                                        TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
@NotNull Optional<Record> fetchOptional(ResultSet rs,
                                        Field<?>... fields)
                                 throws DataAccessException,
                                        TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
@NotNull Optional<Record> fetchOptional(ResultSet rs,
                                        DataType<?>... types)
                                 throws DataAccessException,
                                        TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
@NotNull Optional<Record> fetchOptional(ResultSet rs,
                                        Class<?>... types)
                                 throws DataAccessException,
                                        TooManyRowsException

Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting jOOQ record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue

@Nullable
@Support
@Nullable Object fetchValue(ResultSet rs)
                     throws DataAccessException,
                            TooManyRowsException,
                            InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchValue

@Nullable
@Support
<T> T fetchValue(ResultSet rs,
                 Field<T> field)
          throws DataAccessException,
                 TooManyRowsException,
                 InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional field argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchValue

@Nullable
@Support
<T> T fetchValue(ResultSet rs,
                 DataType<T> type)
          throws DataAccessException,
                 TooManyRowsException,
                 InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchValue

@Nullable
@Support
<T> T fetchValue(ResultSet rs,
                 Class<T> type)
          throws DataAccessException,
                 TooManyRowsException,
                 InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchOptionalValue

@NotNull
@Support
@NotNull Optional<?> fetchOptionalValue(ResultSet rs)
                                 throws DataAccessException,
                                        TooManyRowsException,
                                        InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchOptionalValue

@NotNull
@Support
<T> @NotNull Optional<T> fetchOptionalValue(ResultSet rs,
                                            Field<T> field)
                                     throws DataAccessException,
                                            TooManyRowsException,
                                            InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional field argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchOptionalValue

@NotNull
@Support
<T> @NotNull Optional<T> fetchOptionalValue(ResultSet rs,
                                            DataType<T> type)
                                     throws DataAccessException,
                                            TooManyRowsException,
                                            InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchOptionalValue

@NotNull
@Support
<T> @NotNull Optional<T> fetchOptionalValue(ResultSet rs,
                                            Class<T> type)
                                     throws DataAccessException,
                                            TooManyRowsException,
                                            InvalidResultException

Fetch a record from a JDBC ResultSet and return the only contained value.

This will internally fetch all records and throw an exception if there was more than one resulting record.

The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The resulting value

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

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

fetchValues

@NotNull
@Support
@NotNull List<?> fetchValues(ResultSet rs)
                      throws DataAccessException,
                             InvalidResultException

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

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

fetchValues

@NotNull
@Support
<T> @NotNull List<T> fetchValues(ResultSet rs,
                                 Field<T> field)
                          throws DataAccessException,
                                 InvalidResultException

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

The additional field argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

field - The field to use in the desired output

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

fetchValues

@NotNull
@Support
<T> @NotNull List<T> fetchValues(ResultSet rs,
                                 DataType<T> type)
                          throws DataAccessException,
                                 InvalidResultException

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

The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data type to use in the desired output

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

fetchValues

@NotNull
@Support
<T> @NotNull List<T> fetchValues(ResultSet rs,
                                 Class<T> type)
                          throws DataAccessException,
                                 InvalidResultException

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

The additional type argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

type - The data types to use in the desired output

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

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

fetchLazy

@NotNull
@Support
@NotNull Cursor<Record> fetchLazy(ResultSet rs)
                           throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Cursor.

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

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
@NotNull Cursor<Record> fetchLazy(ResultSet rs,
                                  Field<?>... fields)
                           throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Cursor.

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

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
@NotNull Cursor<Record> fetchLazy(ResultSet rs,
                                  DataType<?>... types)
                           throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Cursor.

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

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
@NotNull Cursor<Record> fetchLazy(ResultSet rs,
                                  Class<?>... types)
                           throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Cursor.

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

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(ResultSet rs)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(ResultSet rs,
                                                    Field<?>... fields)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(ResultSet rs,
                                                    DataType<?>... types)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(ResultSet rs,
                                                    Class<?>... types)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    ResultSet rs)

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

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    ResultSet rs,
                                                    Field<?>... fields)

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

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    ResultSet rs,
                                                    DataType<?>... types)

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

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

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

fetchAsync

@NotNull
@Support
@NotNull CompletionStage<Result<Record>> fetchAsync(Executor executor,
                                                    ResultSet rs,
                                                    Class<?>... types)

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

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

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

fetchStream

@NotNull
@Support
@NotNull Stream<Record> fetchStream(ResultSet rs)
                             throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Stream.

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

Parameters:

rs - The JDBC ResultSet to fetch data from

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@NotNull
@Support
@NotNull Stream<Record> fetchStream(ResultSet rs,
                                    Field<?>... fields)
                             throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Stream.

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

The additional fields argument is used by jOOQ to coerce field names and data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

fields - The fields to use in the desired output

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@NotNull
@Support
@NotNull Stream<Record> fetchStream(ResultSet rs,
                                    DataType<?>... types)
                             throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Stream.

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

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@NotNull
@Support
@NotNull Stream<Record> fetchStream(ResultSet rs,
                                    Class<?>... types)
                             throws DataAccessException

Wrap a JDBC ResultSet into a jOOQ Stream.

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

The additional types argument is used by jOOQ to coerce data types to the desired output

Parameters:

rs - The JDBC ResultSet to fetch data from

types - The data types to use in the desired output

Returns:

The resulting stream

Throws:

DataAccessException - if something went wrong executing the query

fetchFromTXT

@NotNull
@Support
@NotNull Result<Record> fetchFromTXT(String string)
                              throws DataAccessException

Fetch all data from a formatted string.

The supplied string is supposed to be formatted in a human-readable way. This is the same as calling fetchFromTXT(string, "{null}")

Parameters:

string - The formatted string

Returns:

The transformed result. This will never be null.

Throws:

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

See Also:

fetchFromTXT(String, String)

fetchFromTXT

@NotNull
@Support
@NotNull Result<Record> fetchFromTXT(String string,
                                     String nullLiteral)
                              throws DataAccessException

Fetch all data from a formatted string.

This method supports parsing results from two types of human-readable formats:

The jOOQ Formattable.format()

This format is recognised by the fact that the first line starts with a "plus" sign:

 +-----+-----+--------------------------+
 |COL1 |COL2 |COL3 containing whitespace|
 +-----+-----+--------------------------+
 |val1 |1    |some text                 |
 |val2 | 2   | more text                |
 +-----+-----+--------------------------+
 

This method will decode the above formatted string according to the following rules:

• The number of columns is defined by the number of dash groups in the first line. Groups are separated by exactly one "plus" sign
• The column types are VARCHAR(N) where N = number of dashes per dash group
• The column names are defined by the trimmed text contained in the second row
• The data is defined by the trimmed text contained in the subsequent rows

The H2 database test data format

The supplied string is supposed to be formatted in the following, human-readable way:

 COL1  COL2   COL3 containing whitespace
 ----- ----   --------------------------
 val1  1      some text
 val2   2      more text
 

This method will decode the above formatted string according to the following rules:

• The number of columns is defined by the number of dash groups in the second line. Groups are separated by space(s)
• The column types are VARCHAR(N) where N = number of dashes per dash group
• The column names are defined by the trimmed text contained in the first row
• The data is defined by the trimmed text contained in the subsequent rows

Both parsing methods

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

Parameters:

string - The formatted string

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

Returns:

The transformed result. This will never be null.

Throws:

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

fetchFromHTML

@NotNull
@Support
@NotNull Result<Record> fetchFromHTML(String string)
                               throws DataAccessException

Convert an HTML table into a jOOQ Result.

This is the inverse operation of Formattable.formatHTML(). It works according to the following parsing rules:

• The input is expected to be well-formed XML. XHTML conformance is not required - i.e. unknown elements / attributes, or elements / attributes not specified here, such as <caption>, <thead>, <tbody> are simply ignored.
• The surrounding <table> element is optional, but it may appear only once
• A single row containing table headings <th> is allowed. Further rows containing table headings are ignored. Table headings define field names. In the absence of table headings, field names are generated.
• The first row <tr> specifies the number of columns in the table (regardless if it contains table headings or not). Subsequent rows containing less columns will be padded. Subsequent rows containing more columns will be truncated.
• Comments are ignored
• Nested tables are not supported

Ideal input looks like this:

 <table>
 <tr><th>COL1</th><th>COL2</th></tr>
 <tr><td>1</td><td>a</td></tr>
 <tr><td>2</td><td>b</td></tr>
 </table>
 
 

Parameters:

string - The HTML-formatted string.

Returns:

The transformed result. This will never be null.

Throws:

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

fetchFromCSV

@NotNull
@Support
@NotNull Result<Record> fetchFromCSV(String string)
                              throws DataAccessException

Fetch all data from a CSV string.

This is the same as calling fetchFromCSV(string, ',') and the inverse of calling Formattable.formatCSV(). The first row of the CSV data is required to hold field name information. Subsequent rows may contain data, which is interpreted as String. Use the various conversion methods to retrieve other data types from the Result:

• Result.getValues(Field, Class)
• Result.getValues(int, Class)
• Result.getValues(String, Class)
• Result.getValues(Field, Converter)
• Result.getValues(int, Converter)
• Result.getValues(String, Converter)

Missing values result in null. Empty values result in empty Strings

Parameters:

string - The CSV string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String, char)

fetchFromCSV

@NotNull
@Support
@NotNull Result<Record> fetchFromCSV(String string,
                                     char delimiter)
                              throws DataAccessException

Fetch all data from a CSV string.

This is inverse of calling Formattable.formatCSV(char). The first row of the CSV data is required to hold field name information. Subsequent rows may contain data, which is interpreted as String. Use the various conversion methods to retrieve other data types from the Result:

• Result.getValues(Field, Class)
• Result.getValues(int, Class)
• Result.getValues(String, Class)
• Result.getValues(Field, Converter)
• Result.getValues(int, Converter)
• Result.getValues(String, Converter)

Missing values result in null. Empty values result in empty Strings

Parameters:

string - The CSV string

delimiter - The delimiter to expect between records

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String), fetchFromStringData(List)

fetchFromCSV

@NotNull
@Support
@NotNull Result<Record> fetchFromCSV(String string,
                                     boolean header)
                              throws DataAccessException

Fetch all data from a CSV string.

This is the same as calling fetchFromCSV(string, ',') and the inverse of calling Formattable.formatCSV(boolean). Rows may contain data, which is interpreted as String. Use the various conversion methods to retrieve other data types from the Result:

• Result.getValues(Field, Class)
• Result.getValues(int, Class)
• Result.getValues(String, Class)
• Result.getValues(Field, Converter)
• Result.getValues(int, Converter)
• Result.getValues(String, Converter)

Missing values result in null. Empty values result in empty Strings

Parameters:

string - The CSV string

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

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String, char)

fetchFromCSV

@NotNull
@Support
@NotNull Result<Record> fetchFromCSV(String string,
                                     boolean header,
                                     char delimiter)
                              throws DataAccessException

Fetch all data from a CSV string.

This is inverse of calling Formattable.formatCSV(boolean, char). Rows may contain data, which are interpreted as String. Use the various conversion methods to retrieve other data types from the Result:

• Result.getValues(Field, Class)
• Result.getValues(int, Class)
• Result.getValues(String, Class)
• Result.getValues(Field, Converter)
• Result.getValues(int, Converter)
• Result.getValues(String, Converter)

Missing values result in null. Empty values result in empty Strings

Parameters:

string - The CSV string

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

delimiter - The delimiter to expect between records

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the CSV file

See Also:

fetchFromCSV(String), fetchFromStringData(List)

fetchFromJSON

@NotNull
@Support
@NotNull Result<Record> fetchFromJSON(String string)

Fetch all data from a JSON string.

This is the inverse of calling Formattable.formatJSON(). Use the various conversion methods to retrieve other data types from the Result:

• Result.getValues(Field, Class)
• Result.getValues(int, Class)
• Result.getValues(String, Class)
• Result.getValues(Field, Converter)
• Result.getValues(int, Converter)
• Result.getValues(String, Converter)

Missing values result in null. Empty values result in empty Strings

Parameters:

string - The JSON string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the JSON file

fetchFromXML

@NotNull
@Support
@NotNull Result<Record> fetchFromXML(String string)

Fetch all data from an XML string.

This is the inverse of calling Formattable.formatXML(). Use the various conversion methods to retrieve other data types from the Result:

• Result.getValues(Field, Class)
• Result.getValues(int, Class)
• Result.getValues(String, Class)
• Result.getValues(Field, Converter)
• Result.getValues(int, Converter)
• Result.getValues(String, Converter)

Missing values result in null. Empty values result in empty Strings

Parameters:

string - The XML string

Returns:

The transformed result. This will never be null.

Throws:

DataAccessException - If anything went wrong parsing the XML file

fetchFromStringData

@NotNull
@Support
@NotNull Result<Record> fetchFromStringData(String[]... data)

Fetch all data from a list of strings.

This is used by methods such as

• fetchFromCSV(String)
• fetchFromTXT(String)

The first element of the argument list should contain column names. Subsequent elements contain actual data. The degree of all arrays contained in the argument should be the same, although this is not a requirement. jOOQ will ignore excess data, and fill missing data with null.

Parameters:

data - The data to be transformed into a Result

Returns:

The transformed result. This will never be null.

See Also:

fetchFromStringData(List)

fetchFromStringData

@NotNull
@Support
@NotNull Result<Record> fetchFromStringData(List<String[]> data)

Fetch all data from a list of strings.

This is used by methods such as

• fetchFromCSV(String)
• fetchFromTXT(String)

The first element of the argument list should contain column names. Subsequent elements contain actual data. The degree of all arrays contained in the argument should be the same, although this is not a requirement. jOOQ will ignore excess data, and fill missing data with null.

Parameters:

data - The data to be transformed into a Result

Returns:

The transformed result. This will never be null.

fetchFromStringData

@NotNull
@Support
@NotNull Result<Record> fetchFromStringData(List<String[]> data,
                                            boolean header)

Fetch all data from a list of strings.

This is used by methods such as

• fetchFromCSV(String)
• fetchFromTXT(String)

The degree of all arrays contained in the argument should be the same, although this is not a requirement. jOOQ will ignore excess data, and fill missing data with null.

Parameters:

data - The data to be transformed into a Result

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

Returns:

The transformed result. This will never be null.

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(String alias)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(String alias,
                         String... fieldAliases)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(String alias,
                         Collection<String> fieldAliases)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(Name alias)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(Name alias,
                         Name... fieldAliases)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(Name alias,
                         Collection<? extends Name> fieldAliases)

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

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

with

@Deprecated
@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(String alias,
                         Function<? super Field<?>,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

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

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

This works in a similar way as with(String, String...), except that all column names are produced by a function that receives the CTE's Select columns as input.

with

@Deprecated
@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep with(String alias,
                         BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

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

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

This works in a similar way as with(String, String...), except that all column names are produced by a function that receives the CTE's Select columns and their column indexes as input.

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep1 with(String alias,
                          String fieldAlias1)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep2 with(String alias,
                          String fieldAlias1,
                          String fieldAlias2)

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep1 with(Name alias,
                          Name fieldAlias1)

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep2 with(Name alias,
                          Name fieldAlias1,
                          Name fieldAlias2)

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

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

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

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithStep with(CommonTableExpression<?>... tables)

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

Reusable CommonTableExpression types can be constructed through

• DSL.name(String...)
• Name.fields(String...)
• DerivedColumnList.as(Select)

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

with

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithStep with(Collection<? extends CommonTableExpression<?>> tables)

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

Reusable CommonTableExpression types can be constructed through

• DSL.name(String...)
• Name.fields(String...)
• DerivedColumnList.as(Select)

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(String alias)

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(String alias,
                                  String... fieldAliases)

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(String alias,
                                  Collection<String> fieldAliases)

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(Name alias)

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(Name alias,
                                  Name... fieldAliases)

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(Name alias,
                                  Collection<? extends Name> fieldAliases)

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

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

withRecursive

@Deprecated
@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep withRecursive(String alias,
                                  Function<? super Field<?>,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

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

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

This works in a similar way as with(String, String...), except that all column names are produced by a function that receives the CTE's Select columns as input.

withRecursive

@Deprecated
@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA,VERTICA})
@NotNull WithAsStep withRecursive(String alias,
                                  BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

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

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

This works in a similar way as with(String, String...), except that all column names are produced by a function that receives the CTE's Select columns and their column indexes as input.

withRecursive

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep1 withRecursive(String alias,
                                   String fieldAlias1)

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithAsStep1 withRecursive(Name alias,
                                   Name fieldAlias1)

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

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

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

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithStep withRecursive(CommonTableExpression<?>... tables)

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

Reusable CommonTableExpression types can be constructed through

• DSL.name(String...)
• Name.fields(String...)
• DerivedColumnList.as(Select)

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

withRecursive

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,MARIADB,MYSQL_8_0,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull WithStep withRecursive(Collection<? extends CommonTableExpression<?>> tables)

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

Reusable CommonTableExpression types can be constructed through

• DSL.name(String...)
• Name.fields(String...)
• DerivedColumnList.as(Select)

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

selectFrom

@NotNull
@Support
<R extends Record> @NotNull SelectWhereStep<R> selectFrom(Table<R> table)

Create a new DSL select statement, projecting the known columns from a table.

This will project the known columns from the argument table querying TableLike.fields(). If no known columns are available (e.g. because the table has been created using DSL.table(String)), then SELECT * is projected.

Example:

 SELECT table.col1, table.col2 FROM table
 

selectFrom

@NotNull
@Support
@NotNull SelectWhereStep<Record> selectFrom(Name table)

Create a new DSL select statement, projecting *.

Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.

Example:

 SELECT * FROM table
 

See Also:

DSL.table(Name)

selectFrom

@NotNull
@Support
@PlainSQL
@NotNull SelectWhereStep<Record> selectFrom(SQL sql)

Create a new DSL select statement, projecting *.

Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.

Example:

 SELECT * FROM table
 

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

See Also:

DSL.table(SQL), SQL

selectFrom

@NotNull
@Support
@PlainSQL
@NotNull SelectWhereStep<Record> selectFrom(String sql)

Create a new DSL select statement, projecting *.

Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.

Example:

 SELECT * FROM table
 

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

See Also:

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

selectFrom

@NotNull
@Support
@PlainSQL
@NotNull SelectWhereStep<Record> selectFrom(String sql,
                                            Object... bindings)

Create a new DSL select statement, projecting *.

Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.

Example:

 SELECT * FROM table
 

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

See Also:

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

selectFrom

@NotNull
@Support
@PlainSQL
@NotNull SelectWhereStep<Record> selectFrom(String sql,
                                            QueryPart... parts)

Create a new DSL select statement, projecting *.

Without knowing any columns from the argument table (see selectFrom(Table)), this will project SELECT *.

Example:

 SELECT * FROM table
 

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

See Also:

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

select

@NotNull
@Support
@NotNull SelectSelectStep<Record> select(Collection<? extends SelectFieldOrAsterisk> fields)

Create a new DSL select statement.

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

Example:

 DSLContext create = DSL.using(configuration);

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

Note that passing an empty collection conveniently produces SELECT * semantics, i.e. it:

• Renders SELECT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
• Renders SELECT * if not all columns are known, e.g. when using plain SQL

See Also:

DSL.select(Collection)

select

@NotNull
@Support
@NotNull SelectSelectStep<Record> select(SelectFieldOrAsterisk... fields)

Create a new DSL select statement.

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

Example:

 DSLContext create = DSL.using(configuration);

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

Note that passing an empty collection conveniently produces SELECT * semantics, i.e. it:

• Renders SELECT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
• Renders SELECT * if not all columns are known, e.g. when using plain SQL

See Also:

DSL.select(SelectFieldOrAsterisk...)

select

@NotNull
@Support
<T1> @NotNull SelectSelectStep<Record1<T1>> select(SelectField<T1> field1)

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

@NotNull
@Support
<T1,T2> @NotNull SelectSelectStep<Record2<T1,T2>> select(SelectField<T1> field1,
                                                                     SelectField<T2> field2)

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

select

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

@NotNull
@Support
@NotNull SelectSelectStep<Record> selectDistinct(Collection<? extends SelectFieldOrAsterisk> fields)

Create a new DSL select statement.

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

Example:

 DSLContext create = DSL.using(configuration);

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

Note that passing an empty collection conveniently produces SELECT DISTINCT * semantics, i.e. it:

• Renders SELECT DISTINCT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
• Renders SELECT DISTINCT * if not all columns are known, e.g. when using plain SQL

See Also:

DSL.selectDistinct(Collection)

selectDistinct

@NotNull
@Support
@NotNull SelectSelectStep<Record> selectDistinct(SelectFieldOrAsterisk... fields)

Create a new DSL select statement.

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

Example:

 DSLContext create = DSL.using(configuration);

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

Note that passing an empty collection conveniently produces SELECT DISTINCT * semantics, i.e. it:

• Renders SELECT DISTINCT tab1.col1, tab1.col2, ..., tabN.colN if all columns are known
• Renders SELECT DISTINCT * if not all columns are known, e.g. when using plain SQL

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1> @NotNull SelectSelectStep<Record1<T1>> selectDistinct(SelectField<T1> field1)

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

@NotNull
@Support
<T1,T2> @NotNull SelectSelectStep<Record2<T1,T2>> selectDistinct(SelectField<T1> field1,
                                                                             SelectField<T2> field2)

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

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

See Also:

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

selectDistinct

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

Create a new DSL select statement.

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

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

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field10, field11)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> @NotNull SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                        SelectField<T2> field2,
                                                                                                                                                                                                                                                                        SelectField<T3> field3,
                                                                                                                                                                                                                                                                        SelectField<T4> field4,
                                                                                                                                                                                                                                                                        SelectField<T5> field5,
                                                                                                                                                                                                                                                                        SelectField<T6> field6,
                                                                                                                                                                                                                                                                        SelectField<T7> field7,
                                                                                                                                                                                                                                                                        SelectField<T8> field8,
                                                                                                                                                                                                                                                                        SelectField<T9> field9,
                                                                                                                                                                                                                                                                        SelectField<T10> field10,
                                                                                                                                                                                                                                                                        SelectField<T11> field11,
                                                                                                                                                                                                                                                                        SelectField<T12> field12)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row12.in(Select), Row12.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field11, field12)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> @NotNull SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                            SelectField<T2> field2,
                                                                                                                                                                                                                                                                                            SelectField<T3> field3,
                                                                                                                                                                                                                                                                                            SelectField<T4> field4,
                                                                                                                                                                                                                                                                                            SelectField<T5> field5,
                                                                                                                                                                                                                                                                                            SelectField<T6> field6,
                                                                                                                                                                                                                                                                                            SelectField<T7> field7,
                                                                                                                                                                                                                                                                                            SelectField<T8> field8,
                                                                                                                                                                                                                                                                                            SelectField<T9> field9,
                                                                                                                                                                                                                                                                                            SelectField<T10> field10,
                                                                                                                                                                                                                                                                                            SelectField<T11> field11,
                                                                                                                                                                                                                                                                                            SelectField<T12> field12,
                                                                                                                                                                                                                                                                                            SelectField<T13> field13)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row13.in(Select), Row13.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field12, field13)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> @NotNull SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                SelectField<T14> field14)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row14.in(Select), Row14.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field13, field14)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> @NotNull SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                    SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                    SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                    SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                    SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                    SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                    SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                    SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                    SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                    SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                    SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                    SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                    SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                    SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                    SelectField<T15> field15)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row15.in(Select), Row15.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field14, field15)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> @NotNull SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                        SelectField<T16> field16)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row16.in(Select), Row16.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field15, field16)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> @NotNull SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                            SelectField<T17> field17)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row17.in(Select), Row17.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field16, field17)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> @NotNull SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T18> field18)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row18.in(Select), Row18.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field17, field18)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> @NotNull SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                    SelectField<T19> field19)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row19.in(Select), Row19.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field18, field19)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> @NotNull SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                        SelectField<T20> field20)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row20.in(Select), Row20.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field19, field20)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> @NotNull SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            SelectField<T21> field21)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row21.in(Select), Row21.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field20, field21)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectDistinct

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> @NotNull SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> selectDistinct(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SelectField<T22> field22)

Create a new DSL select statement.

This is the same as selectDistinct(SelectFieldOrAsterisk...), except that it declares additional record-level typesafety, which is needed by Row22.in(Select), Row22.equal(Select) and other predicate building methods taking subselect arguments.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectDistinct(SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField, SelectField) instead.

Example:

 using(configuration)
       .selectDistinct(field1, field2, field3, .., field21, field22)
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectDistinct(SelectFieldOrAsterisk...), selectDistinct(SelectFieldOrAsterisk...)

selectZero

@NotNull
@Support
@NotNull SelectSelectStep<Record1<Integer>> selectZero()

Create a new DSL select statement for a constant 0 literal.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectZero() instead.

Example:

 DSLContext create = DSL.using(configuration);

 create.selectZero()
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.zero(), DSL.selectZero()

selectOne

@NotNull
@Support
@NotNull SelectSelectStep<Record1<Integer>> selectOne()

Create a new DSL select statement for a constant 1 literal.

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectOne() instead.

Example:

 DSLContext create = DSL.using(configuration);

 create.selectOne()
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.one(), DSL.selectOne()

selectCount

@NotNull
@Support
@NotNull SelectSelectStep<Record1<Integer>> selectCount()

Create a new DSL select statement for COUNT(*).

This creates an attached, renderable and executable SELECT statement from this DSLContext. If you don't need to render or execute this SELECT statement (e.g. because you want to create a subselect), consider using the static DSL.selectCount() instead.

Example:

 DSLContext create = DSL.using(configuration);

 create.selectCount()
       .from(table1)
       .join(table2).on(field1.equal(field2))
       .where(field1.greaterThan(100))
       .orderBy(field2);
 

See Also:

DSL.selectCount()

selectQuery

@NotNull
@Support
@NotNull SelectQuery<Record> selectQuery()

Create a new SelectQuery

selectQuery

@NotNull
@Support
<R extends Record> @NotNull SelectQuery<R> selectQuery(TableLike<R> table)

Create a new SelectQuery

Parameters:

table - The table to select data from

Returns:

The new SelectQuery

insertQuery

@NotNull
@Support
<R extends Record> @NotNull InsertQuery<R> insertQuery(Table<R> into)

Create a new InsertQuery

Parameters:

into - The table to insert data into

Returns:

The new InsertQuery

insertInto

@NotNull
@Support
<R extends Record> @NotNull InsertSetStep<R> insertInto(Table<R> into)

Create a new DSL insert statement.

This type of insert may feel more convenient to some users, as it uses the UPDATE statement's SET a = b syntax.

Example:

 DSLContext create = DSL.using(configuration);

 create.insertInto(table)
       .set(field1, value1)
       .set(field2, value2)
       .newRecord()
       .set(field1, value3)
       .set(field2, value4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1> @NotNull InsertValuesStep1<R,T1> insertInto(Table<R> into,
                                                                              Field<T1> field1)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1)
       .values(field1)
       .values(field1)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2> @NotNull InsertValuesStep2<R,T1,T2> insertInto(Table<R> into,
                                                                                                Field<T1> field1,
                                                                                                Field<T2> field2)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2)
       .values(field1, field2)
       .values(field1, field2)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3> @NotNull InsertValuesStep3<R,T1,T2,T3> insertInto(Table<R> into,
                                                                                                                  Field<T1> field1,
                                                                                                                  Field<T2> field2,
                                                                                                                  Field<T3> field3)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3)
       .values(field1, field2, field3)
       .values(field1, field2, field3)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4> @NotNull InsertValuesStep4<R,T1,T2,T3,T4> insertInto(Table<R> into,
                                                                                                                                    Field<T1> field1,
                                                                                                                                    Field<T2> field2,
                                                                                                                                    Field<T3> field3,
                                                                                                                                    Field<T4> field4)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, field4)
       .values(field1, field2, field3, field4)
       .values(field1, field2, field3, field4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5> @NotNull InsertValuesStep5<R,T1,T2,T3,T4,T5> insertInto(Table<R> into,
                                                                                                                                                      Field<T1> field1,
                                                                                                                                                      Field<T2> field2,
                                                                                                                                                      Field<T3> field3,
                                                                                                                                                      Field<T4> field4,
                                                                                                                                                      Field<T5> field5)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, field4, field5)
       .values(field1, field2, field3, field4, field5)
       .values(field1, field2, field3, field4, field5)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6> @NotNull InsertValuesStep6<R,T1,T2,T3,T4,T5,T6> insertInto(Table<R> into,
                                                                                                                                                                        Field<T1> field1,
                                                                                                                                                                        Field<T2> field2,
                                                                                                                                                                        Field<T3> field3,
                                                                                                                                                                        Field<T4> field4,
                                                                                                                                                                        Field<T5> field5,
                                                                                                                                                                        Field<T6> field6)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field5, field6)
       .values(valueA1, valueA2, valueA3, .., valueA5, valueA6)
       .values(valueB1, valueB2, valueB3, .., valueB5, valueB6)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7> @NotNull InsertValuesStep7<R,T1,T2,T3,T4,T5,T6,T7> insertInto(Table<R> into,
                                                                                                                                                                                          Field<T1> field1,
                                                                                                                                                                                          Field<T2> field2,
                                                                                                                                                                                          Field<T3> field3,
                                                                                                                                                                                          Field<T4> field4,
                                                                                                                                                                                          Field<T5> field5,
                                                                                                                                                                                          Field<T6> field6,
                                                                                                                                                                                          Field<T7> field7)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field6, field7)
       .values(valueA1, valueA2, valueA3, .., valueA6, valueA7)
       .values(valueB1, valueB2, valueB3, .., valueB6, valueB7)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> @NotNull InsertValuesStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> insertInto(Table<R> into,
                                                                                                                                                                                                            Field<T1> field1,
                                                                                                                                                                                                            Field<T2> field2,
                                                                                                                                                                                                            Field<T3> field3,
                                                                                                                                                                                                            Field<T4> field4,
                                                                                                                                                                                                            Field<T5> field5,
                                                                                                                                                                                                            Field<T6> field6,
                                                                                                                                                                                                            Field<T7> field7,
                                                                                                                                                                                                            Field<T8> field8)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field7, field8)
       .values(valueA1, valueA2, valueA3, .., valueA7, valueA8)
       .values(valueB1, valueB2, valueB3, .., valueB7, valueB8)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> @NotNull InsertValuesStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> insertInto(Table<R> into,
                                                                                                                                                                                                                              Field<T1> field1,
                                                                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                                                                              Field<T8> field8,
                                                                                                                                                                                                                              Field<T9> field9)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field8, field9)
       .values(valueA1, valueA2, valueA3, .., valueA8, valueA9)
       .values(valueB1, valueB2, valueB3, .., valueB8, valueB9)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> @NotNull InsertValuesStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> insertInto(Table<R> into,
                                                                                                                                                                                                                                                   Field<T1> field1,
                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                   Field<T10> field10)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field9, field10)
       .values(valueA1, valueA2, valueA3, .., valueA9, valueA10)
       .values(valueB1, valueB2, valueB3, .., valueB9, valueB10)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> @NotNull InsertValuesStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                       Field<T1> field1,
                                                                                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                                                                                       Field<T8> field8,
                                                                                                                                                                                                                                                                       Field<T9> field9,
                                                                                                                                                                                                                                                                       Field<T10> field10,
                                                                                                                                                                                                                                                                       Field<T11> field11)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field10, field11)
       .values(valueA1, valueA2, valueA3, .., valueA10, valueA11)
       .values(valueB1, valueB2, valueB3, .., valueB10, valueB11)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> @NotNull InsertValuesStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                           Field<T1> field1,
                                                                                                                                                                                                                                                                                           Field<T2> field2,
                                                                                                                                                                                                                                                                                           Field<T3> field3,
                                                                                                                                                                                                                                                                                           Field<T4> field4,
                                                                                                                                                                                                                                                                                           Field<T5> field5,
                                                                                                                                                                                                                                                                                           Field<T6> field6,
                                                                                                                                                                                                                                                                                           Field<T7> field7,
                                                                                                                                                                                                                                                                                           Field<T8> field8,
                                                                                                                                                                                                                                                                                           Field<T9> field9,
                                                                                                                                                                                                                                                                                           Field<T10> field10,
                                                                                                                                                                                                                                                                                           Field<T11> field11,
                                                                                                                                                                                                                                                                                           Field<T12> field12)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field11, field12)
       .values(valueA1, valueA2, valueA3, .., valueA11, valueA12)
       .values(valueB1, valueB2, valueB3, .., valueB11, valueB12)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> @NotNull InsertValuesStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                               Field<T1> field1,
                                                                                                                                                                                                                                                                                                               Field<T2> field2,
                                                                                                                                                                                                                                                                                                               Field<T3> field3,
                                                                                                                                                                                                                                                                                                               Field<T4> field4,
                                                                                                                                                                                                                                                                                                               Field<T5> field5,
                                                                                                                                                                                                                                                                                                               Field<T6> field6,
                                                                                                                                                                                                                                                                                                               Field<T7> field7,
                                                                                                                                                                                                                                                                                                               Field<T8> field8,
                                                                                                                                                                                                                                                                                                               Field<T9> field9,
                                                                                                                                                                                                                                                                                                               Field<T10> field10,
                                                                                                                                                                                                                                                                                                               Field<T11> field11,
                                                                                                                                                                                                                                                                                                               Field<T12> field12,
                                                                                                                                                                                                                                                                                                               Field<T13> field13)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field12, field13)
       .values(valueA1, valueA2, valueA3, .., valueA12, valueA13)
       .values(valueB1, valueB2, valueB3, .., valueB12, valueB13)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> @NotNull InsertValuesStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                   Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                   Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                   Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                   Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                   Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                   Field<T14> field14)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field13, field14)
       .values(valueA1, valueA2, valueA3, .., valueA13, valueA14)
       .values(valueB1, valueB2, valueB3, .., valueB13, valueB14)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> @NotNull InsertValuesStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                       Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                       Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                       Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                       Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                       Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                       Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                       Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                       Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                       Field<T15> field15)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field14, field15)
       .values(valueA1, valueA2, valueA3, .., valueA14, valueA15)
       .values(valueB1, valueB2, valueB3, .., valueB14, valueB15)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> @NotNull InsertValuesStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                           Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                           Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                           Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                           Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                           Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                           Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                           Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                           Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                           Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                           Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                           Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                           Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                           Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                           Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                           Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                           Field<T16> field16)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field15, field16)
       .values(valueA1, valueA2, valueA3, .., valueA15, valueA16)
       .values(valueB1, valueB2, valueB3, .., valueB15, valueB16)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> @NotNull InsertValuesStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                               Field<T17> field17)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field16, field17)
       .values(valueA1, valueA2, valueA3, .., valueA16, valueA17)
       .values(valueB1, valueB2, valueB3, .., valueB16, valueB17)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> @NotNull InsertValuesStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T18> field18)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field17, field18)
       .values(valueA1, valueA2, valueA3, .., valueA17, valueA18)
       .values(valueB1, valueB2, valueB3, .., valueB17, valueB18)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> @NotNull InsertValuesStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                       Field<T19> field19)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field18, field19)
       .values(valueA1, valueA2, valueA3, .., valueA18, valueA19)
       .values(valueB1, valueB2, valueB3, .., valueB18, valueB19)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> @NotNull InsertValuesStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           Field<T20> field20)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field19, field20)
       .values(valueA1, valueA2, valueA3, .., valueA19, valueA20)
       .values(valueB1, valueB2, valueB3, .., valueB19, valueB20)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> @NotNull InsertValuesStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T21> field21)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field20, field21)
       .values(valueA1, valueA2, valueA3, .., valueA20, valueA21)
       .values(valueB1, valueB2, valueB3, .., valueB20, valueB21)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> @NotNull InsertValuesStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> insertInto(Table<R> into,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T22> field22)

Create a new DSL insert statement.

Example:

 using(configuration)
       .insertInto(table, field1, field2, field3, .., field21, field22)
       .values(valueA1, valueA2, valueA3, .., valueA21, valueA22)
       .values(valueB1, valueB2, valueB3, .., valueB21, valueB22)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record> @NotNull InsertValuesStepN<R> insertInto(Table<R> into,
                                                            Field<?>... fields)

Create a new DSL insert statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.insertInto(table, field1, field2)
       .values(value1, value2)
       .values(value3, value4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

insertInto

@NotNull
@Support
<R extends Record> @NotNull InsertValuesStepN<R> insertInto(Table<R> into,
                                                            Collection<? extends Field<?>> fields)

Create a new DSL insert statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.insertInto(table, field1, field2)
       .values(value1, value2)
       .values(value3, value4)
       .onDuplicateKeyUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .execute();
 

updateQuery

@NotNull
@Support
<R extends Record> @NotNull UpdateQuery<R> updateQuery(Table<R> table)

Create a new UpdateQuery

Parameters:

table - The table to update data into

Returns:

The new UpdateQuery

update

@NotNull
@Support
<R extends Record> @NotNull UpdateSetFirstStep<R> update(Table<R> table)

Create a new DSL update statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.update(table)
       .set(field1, value1)
       .set(field2, value2)
       .where(field1.greaterThan(100))
       .execute();
 

Note that some databases support table expressions more complex than simple table references. In MySQL, for instance, you can write

 create.update(t1.join(t2).on(t1.id.eq(t2.id)))
       .set(t1.value, value1)
       .set(t2.value, value2)
       .where(t1.id.eq(10))
       .execute();
 

mergeInto

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record> @NotNull MergeUsingStep<R> mergeInto(Table<R> table)

Create a new DSL SQL standard MERGE statement.

This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:

dialect	support type	documentation
DB2	SQL:2008 standard and major enhancements	http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. ibm.db2.udb.admin.doc/doc/r0010873.htm
HSQLDB	SQL:2008 standard	http://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA
Oracle	SQL:2008 standard and minor enhancements	http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ statements_9016.htm
SQL Server	Similar to SQL:2008 standard with some major enhancements	http://msdn.microsoft.com/de-de/library/bb510625.aspx
Sybase	Similar to SQL:2008 standard with some major enhancements	http://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html

Example:

 DSLContext create = DSL.using(configuration);

 create.mergeInto(table)
       .using(select)
       .on(condition)
       .whenMatchedThenUpdate()
       .set(field1, value1)
       .set(field2, value2)
       .whenNotMatchedThenInsert(field1, field2)
       .values(value1, value2)
       .execute();
 

Note: Using this method, you can also create an H2-specific MERGE statement without field specification. See also mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1> @NotNull MergeKeyStep1<R,T1> mergeInto(Table<R> table,
                                                                         Field<T1> field1)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2> @NotNull MergeKeyStep2<R,T1,T2> mergeInto(Table<R> table,
                                                                                           Field<T1> field1,
                                                                                           Field<T2> field2)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3> @NotNull MergeKeyStep3<R,T1,T2,T3> mergeInto(Table<R> table,
                                                                                                             Field<T1> field1,
                                                                                                             Field<T2> field2,
                                                                                                             Field<T3> field3)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4> @NotNull MergeKeyStep4<R,T1,T2,T3,T4> mergeInto(Table<R> table,
                                                                                                                               Field<T1> field1,
                                                                                                                               Field<T2> field2,
                                                                                                                               Field<T3> field3,
                                                                                                                               Field<T4> field4)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5> @NotNull MergeKeyStep5<R,T1,T2,T3,T4,T5> mergeInto(Table<R> table,
                                                                                                                                                 Field<T1> field1,
                                                                                                                                                 Field<T2> field2,
                                                                                                                                                 Field<T3> field3,
                                                                                                                                                 Field<T4> field4,
                                                                                                                                                 Field<T5> field5)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6> @NotNull MergeKeyStep6<R,T1,T2,T3,T4,T5,T6> mergeInto(Table<R> table,
                                                                                                                                                                   Field<T1> field1,
                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                   Field<T6> field6)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7> @NotNull MergeKeyStep7<R,T1,T2,T3,T4,T5,T6,T7> mergeInto(Table<R> table,
                                                                                                                                                                                     Field<T1> field1,
                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                     Field<T7> field7)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> @NotNull MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> mergeInto(Table<R> table,
                                                                                                                                                                                                       Field<T1> field1,
                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                       Field<T8> field8)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> @NotNull MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> mergeInto(Table<R> table,
                                                                                                                                                                                                                         Field<T1> field1,
                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                         Field<T9> field9)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> @NotNull MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> mergeInto(Table<R> table,
                                                                                                                                                                                                                                              Field<T1> field1,
                                                                                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                                                                                              Field<T8> field8,
                                                                                                                                                                                                                                              Field<T9> field9,
                                                                                                                                                                                                                                              Field<T10> field10)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> @NotNull MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                  Field<T1> field1,
                                                                                                                                                                                                                                                                  Field<T2> field2,
                                                                                                                                                                                                                                                                  Field<T3> field3,
                                                                                                                                                                                                                                                                  Field<T4> field4,
                                                                                                                                                                                                                                                                  Field<T5> field5,
                                                                                                                                                                                                                                                                  Field<T6> field6,
                                                                                                                                                                                                                                                                  Field<T7> field7,
                                                                                                                                                                                                                                                                  Field<T8> field8,
                                                                                                                                                                                                                                                                  Field<T9> field9,
                                                                                                                                                                                                                                                                  Field<T10> field10,
                                                                                                                                                                                                                                                                  Field<T11> field11)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> @NotNull MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                      Field<T1> field1,
                                                                                                                                                                                                                                                                                      Field<T2> field2,
                                                                                                                                                                                                                                                                                      Field<T3> field3,
                                                                                                                                                                                                                                                                                      Field<T4> field4,
                                                                                                                                                                                                                                                                                      Field<T5> field5,
                                                                                                                                                                                                                                                                                      Field<T6> field6,
                                                                                                                                                                                                                                                                                      Field<T7> field7,
                                                                                                                                                                                                                                                                                      Field<T8> field8,
                                                                                                                                                                                                                                                                                      Field<T9> field9,
                                                                                                                                                                                                                                                                                      Field<T10> field10,
                                                                                                                                                                                                                                                                                      Field<T11> field11,
                                                                                                                                                                                                                                                                                      Field<T12> field12)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> @NotNull MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                          Field<T1> field1,
                                                                                                                                                                                                                                                                                                          Field<T2> field2,
                                                                                                                                                                                                                                                                                                          Field<T3> field3,
                                                                                                                                                                                                                                                                                                          Field<T4> field4,
                                                                                                                                                                                                                                                                                                          Field<T5> field5,
                                                                                                                                                                                                                                                                                                          Field<T6> field6,
                                                                                                                                                                                                                                                                                                          Field<T7> field7,
                                                                                                                                                                                                                                                                                                          Field<T8> field8,
                                                                                                                                                                                                                                                                                                          Field<T9> field9,
                                                                                                                                                                                                                                                                                                          Field<T10> field10,
                                                                                                                                                                                                                                                                                                          Field<T11> field11,
                                                                                                                                                                                                                                                                                                          Field<T12> field12,
                                                                                                                                                                                                                                                                                                          Field<T13> field13)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> @NotNull MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                              Field<T1> field1,
                                                                                                                                                                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                                                                                                                                                                              Field<T8> field8,
                                                                                                                                                                                                                                                                                                                              Field<T9> field9,
                                                                                                                                                                                                                                                                                                                              Field<T10> field10,
                                                                                                                                                                                                                                                                                                                              Field<T11> field11,
                                                                                                                                                                                                                                                                                                                              Field<T12> field12,
                                                                                                                                                                                                                                                                                                                              Field<T13> field13,
                                                                                                                                                                                                                                                                                                                              Field<T14> field14)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> @NotNull MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                  Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                  Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                  Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                  Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                  Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                  Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                  Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                  Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                  Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                  Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                  Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                  Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                  Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                  Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                  Field<T15> field15)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> @NotNull MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                      Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                      Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                      Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                      Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                      Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                      Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                      Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                      Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                      Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                      Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                      Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                      Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                      Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                      Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                      Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                      Field<T16> field16)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> @NotNull MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                          Field<T17> field17)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> @NotNull MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                              Field<T18> field18)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> @NotNull MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                  Field<T19> field19)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> @NotNull MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      Field<T20> field20)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> @NotNull MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Field<T21> field21)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,DERBY,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> @NotNull MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> mergeInto(Table<R> table,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Field<T22> field22)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

See Also:

mergeInto(Table, Field...)

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record> @NotNull MergeKeyStepN<R> mergeInto(Table<R> table,
                                                       Field<?>... fields)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL UPSERT statement (SQLDialect.H2 MERGE) or SQLDialect.HANA UPSERT).

This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:

H2	H2 natively supports this special syntax	http://www.h2database.com/html/grammar.html#merge
HANA	HANA natively supports this syntax	http://help.sap.com/saphelp_hanaplatform/helpdata/en/20/fc06a7751910149892c0d09be21a38/content.htm
PostgreSQL	This database can emulate the H2-specific MERGE statement via INSERT .. ON CONFLICT DO UPDATE	http://www.postgresql.org/docs/9.5/static/sql-insert.html
DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere	These databases can emulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions	See mergeInto(Table) for the standard MERGE statement

mergeInto

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,CUBRID,DB2,FIREBIRD_3_0,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES_9_5,SQLSERVER,SYBASE,TERADATA,VERTICA})
<R extends Record> @NotNull MergeKeyStepN<R> mergeInto(Table<R> table,
                                                       Collection<? extends Field<?>> fields)

Deprecated.

- [#10045] - 3.14.0 - Use the standard SQL MERGE API instead, via mergeInto(Table)

Create a new DSL merge statement (H2-specific syntax).

See Also:

mergeInto(Table, Field...)

deleteQuery

@NotNull
@Support
<R extends Record> @NotNull DeleteQuery<R> deleteQuery(Table<R> table)

Create a new DeleteQuery

Parameters:

table - The table to delete data from

Returns:

The new DeleteQuery

deleteFrom

@NotNull
@Support
<R extends Record> @NotNull DeleteUsingStep<R> deleteFrom(Table<R> table)

Create a new DSL delete statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.deleteFrom(table)
       .where(field1.greaterThan(100))
       .execute();
 

Some but not all databases support aliased tables in delete statements.

delete

@NotNull
@Support
<R extends Record> @NotNull DeleteUsingStep<R> delete(Table<R> table)

Create a new DSL delete statement.

This is an alias for deleteFrom(Table)

batched

void batched(BatchedRunnable runnable)

Run a BatchedRunnable on a BatchedConnection, delaying execution as long as possible before batching.

See Also:

BatchedConnection for details.

batchedResult

<T> T batchedResult(BatchedCallable<T> callable)

Run a BatchedRunnable on a BatchedConnection, delaying execution as long as possible before batching.

See Also:

BatchedConnection for details.

batch

@NotNull
@Support
@NotNull Batch batch(Query... queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This essentially runs the following logic:

 Statement s = connection.createStatement();

 for (Query query : queries) {
     s.addBatch(query.getSQL(true));
 }

 s.execute();
 

See Also:

Statement.executeBatch()

batch

@NotNull
@Support
@NotNull Batch batch(Queries queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This essentially runs the following logic:

 Statement s = connection.createStatement();

 for (Query query : queries) {
     s.addBatch(query.getSQL(true));
 }

 s.execute();
 

See Also:

Statement.executeBatch()

batch

@NotNull
@Support
@PlainSQL
@NotNull Batch batch(String... queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This is a convenience method for calling

batch(query(queries[0]), query(queries[1]), ...)

.

See Also:

query(String), batch(Query...), Statement.executeBatch()

batch

@NotNull
@Support
@NotNull Batch batch(Collection<? extends Query> queries)

Create a batch statement to execute a set of queries in batch mode (without bind values).

This essentially runs the following logic:

 Statement s = connection.createStatement();

 for (Query query : queries) {
     s.addBatch(query.getSQL(true));
 }

 s.execute();
 

See Also:

Statement.executeBatch()

batch

@NotNull
@Support
@NotNull BatchBindStep batch(Query query)

Create a batch statement to execute a set of queries in batch mode (with bind values).

When running

 create.batch(query)
       .bind(valueA1, valueA2)
       .bind(valueB1, valueB2)
       .execute();
 

This essentially runs the following logic:

 Statement s = connection.prepareStatement(query.getSQL(false));

 for (Object[] bindValues : allBindValues) {
     for (Object bindValue : bindValues) {
         s.setXXX(bindValue);
     }

     s.addBatch();
 }

 s.execute();
 

Note: bind values will be inlined to a static batch query as in batch(Query...), if you choose to execute queries with Settings.getStatementType() == StatementType.STATIC_STATEMENT

See Also:

Statement.executeBatch()

batch

@NotNull
@Support
@PlainSQL
@NotNull BatchBindStep batch(String sql)

Create a batch statement to execute a set of queries in batch mode (with bind values).

This is a convenience method for calling

batch(query(sql))

.

See Also:

query(String), batch(Query), Statement.executeBatch()

batch

@NotNull
@Support
@NotNull Batch batch(Query query,
                     Object[]... bindings)

Create a batch statement to execute a set of queries in batch mode (with bind values).

This is a convenience method for calling batch(Query) and then binding values one by one using BatchBindStep.bind(Object...)

Note: bind values will be inlined to a static batch query as in batch(Query...), if you choose to execute queries with Settings.getStatementType() == StatementType.STATIC_STATEMENT

See Also:

batch(Query), Statement.executeBatch()

batch

@NotNull
@Support
@PlainSQL
@NotNull Batch batch(String sql,
                     Object[]... bindings)

Create a batch statement to execute a set of queries in batch mode (with bind values).

This is a convenience method for calling

batch(query(sql), bindings)

.

See Also:

query(String), batch(Query, Object[][]), Statement.executeBatch()

batchStore

@NotNull
@Support
@NotNull Batch batchStore(UpdatableRecord<?>... records)

Create a batch statement to execute a set of INSERT and UPDATE queries in batch mode (with bind values) according to UpdatableRecord.store() semantics.

This batch operation can be executed in two modes:

With Settings.getStatementType() == StatementType.PREPARED_STATEMENT (the default)

In this mode, record order is preserved as much as possible, as long as two subsequent records generate the same SQL (with bind variables). The number of executed batch operations corresponds to [number of distinct rendered SQL statements]. In the worst case, this corresponds to the number of total records.

The record type order is preserved in the way they are passed to this method. This is an example of how statements will be ordered:

 // Let's assume, odd numbers result in INSERTs and even numbers in UPDATES
 // Let's also assume a[n] are all of the same type, just as b[n], c[n]...
 int[] result = create.batchStore(a1, a2, a3, b1, a4, c1, b3, a5)
                      .execute();
 

The above results in result.length == 8 and the following 4 separate batch statements:

1. INSERT a1, a3, a5
2. UPDATE a2, a4
3. INSERT b1, b3
4. INSERT c1

With Settings.getStatementType() == StatementType.STATIC_STATEMENT

This mode may be better for large and complex batch store operations, as the order of records is preserved entirely, and jOOQ can guarantee that only a single batch statement is serialised to the database.

A note on MERGE / UPSERT semantics

This method (just like UpdatableRecord.store()) does not implement the semantics of an actual UPSERT or MERGE statement, which delegates the decision of whether to INSERT or UPDATE a record to the database. The decision is made by the client (jOOQ) depending on whether each individual record has been fetched from the database prior to storing it.

See Also:

UpdatableRecord.store(), Statement.executeBatch()

batchStore

@NotNull
@Support
@NotNull Batch batchStore(Collection<? extends UpdatableRecord<?>> records)

Create a batch statement to execute a set of INSERT and UPDATE queries in batch mode (with bind values) according to UpdatableRecord.store() semantics.

See Also:

batchStore(UpdatableRecord...), UpdatableRecord.store(), Statement.executeBatch()

batchInsert

@NotNull
@Support
@NotNull Batch batchInsert(TableRecord<?>... records)

Create a batch statement to execute a set of INSERT queries in batch mode (with bind values) according to TableRecord.insert() semantics.

See Also:

batchStore(UpdatableRecord...), TableRecord.insert(), Statement.executeBatch()

batchInsert

@NotNull
@Support
@NotNull Batch batchInsert(Collection<? extends TableRecord<?>> records)

Create a batch statement to execute a set of INSERT queries in batch mode (with bind values) according to TableRecord.insert() semantics.

See Also:

batchStore(UpdatableRecord...), Statement.executeBatch()

batchUpdate

@NotNull
@Support
@NotNull Batch batchUpdate(UpdatableRecord<?>... records)

Create a batch statement to execute a set of UPDATE queries in batch mode (with bind values) according to UpdatableRecord.update() semantics.

See Also:

batchStore(UpdatableRecord...), UpdatableRecord.update(), Statement.executeBatch()

batchUpdate

@NotNull
@Support
@NotNull Batch batchUpdate(Collection<? extends UpdatableRecord<?>> records)

Create a batch statement to execute a set of UPDATE queries in batch mode (with bind values) according to UpdatableRecord.update() semantics.

See Also:

batchStore(UpdatableRecord...), UpdatableRecord.update(), Statement.executeBatch()

batchMerge

@NotNull
@Support
@NotNull Batch batchMerge(UpdatableRecord<?>... records)

Create a batch statement to execute a set of MERGE queries in batch mode (with bind values) according to UpdatableRecord.merge() semantics.

See Also:

UpdatableRecord.merge(), Statement.executeBatch()

batchMerge

@NotNull
@Support
@NotNull Batch batchMerge(Collection<? extends UpdatableRecord<?>> records)

Create a batch statement to execute a set of MERGE queries in batch mode (with bind values) according to UpdatableRecord.merge() semantics.

See Also:

UpdatableRecord.merge(), Statement.executeBatch()

batchDelete

@NotNull
@Support
@NotNull Batch batchDelete(UpdatableRecord<?>... records)

Create a batch statement to execute a set of DELETE queries in batch mode (with bind values) according to UpdatableRecord.delete() sematics.

This batch operation can be executed in two modes:

With Settings.getStatementType() == StatementType.PREPARED_STATEMENT (the default)

In this mode, record order is preserved as much as possible, as long as two subsequent records generate the same SQL (with bind variables). The number of executed batch operations corresponds to [number of distinct rendered SQL statements]. In the worst case, this corresponds to the number of total records.

The record type order is preserved in the way they are passed to this method. This is an example of how statements will be ordered:

 // Let's assume a[n] are all of the same type, just as b[n], c[n]...
 int[] result = create.batchDelete(a1, a2, a3, b1, a4, c1, c2, a5)
                      .execute();
 

The above results in result.length == 8 and the following 5 separate batch statements:

1. DELETE a1, a2, a3
2. DELETE b1
3. DELETE a4
4. DELETE c1, c2
5. DELETE a5

With Settings.getStatementType() == StatementType.STATIC_STATEMENT

This mode may be better for large and complex batch delete operations, as the order of records is preserved entirely, and jOOQ can guarantee that only a single batch statement is serialised to the database.

See Also:

UpdatableRecord.delete(), Statement.executeBatch()

batchDelete

@NotNull
@Support
@NotNull Batch batchDelete(Collection<? extends UpdatableRecord<?>> records)

Create a batch statement to execute a set of DELETE queries in batch mode (with bind values) according to UpdatableRecord.delete() sematics.

See Also:

batchDelete(UpdatableRecord...), UpdatableRecord.delete(), Statement.executeBatch()

ddl

@NotNull
@NotNull Queries ddl(Catalog catalog)

Convenience method for Meta.ddl().

See Also:

meta(Catalog...), Meta.ddl()

ddl

@NotNull
@NotNull Queries ddl(Catalog schema,
                     DDLExportConfiguration configuration)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Catalog...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Catalog schema,
                     DDLFlag... flags)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Catalog...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Schema schema)

Convenience method for Meta.ddl().

See Also:

meta(Schema...), Meta.ddl()

ddl

@NotNull
@NotNull Queries ddl(Schema schema,
                     DDLExportConfiguration configuration)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Schema...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Schema schema,
                     DDLFlag... flags)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Schema...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Table<?> table)

Convenience method for Meta.ddl().

See Also:

meta(Table...), Meta.ddl()

ddl

@NotNull
@NotNull Queries ddl(Table<?> table,
                     DDLExportConfiguration configuration)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Table...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Table<?> table,
                     DDLFlag... flags)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Table...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Table<?>... tables)

Convenience method for Meta.ddl().

See Also:

meta(Table...), Meta.ddl()

ddl

@NotNull
@NotNull Queries ddl(Table<?>[] tables,
                     DDLExportConfiguration configuration)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Table...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Table<?>[] tables,
                     DDLFlag... flags)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Table...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Collection<? extends Table<?>> tables)

Convenience method for Meta.ddl().

See Also:

meta(Table...), Meta.ddl()

ddl

@NotNull
@NotNull Queries ddl(Collection<? extends Table<?>> tables,
                     DDLFlag... flags)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Table...), Meta.ddl(DDLExportConfiguration)

ddl

@NotNull
@NotNull Queries ddl(Collection<? extends Table<?>> tables,
                     DDLExportConfiguration configuration)

Convenience method for Meta.ddl(DDLExportConfiguration).

See Also:

meta(Table...), Meta.ddl(DDLExportConfiguration)

setCatalog

@NotNull
@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
@NotNull RowCountQuery setCatalog(String catalog)

Set the current catalog to a new value.

See Also:

DSL.catalog(Name)

setCatalog

@NotNull
@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
@NotNull RowCountQuery setCatalog(Name catalog)

Set the current catalog to a new value.

See Also:

DSL.catalog(Name)

setCatalog

@NotNull
@Support({AURORA_MYSQL,MARIADB,MEMSQL,MYSQL,SQLSERVER,TERADATA})
@NotNull RowCountQuery setCatalog(Catalog catalog)

Set the current catalog to a new value.

setSchema

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
@NotNull RowCountQuery setSchema(String schema)

Set the current schema to a new value.

See Also:

DSL.schema(Name), DSL.setSchema(String)

setSchema

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
@NotNull RowCountQuery setSchema(Name schema)

Set the current schema to a new value.

See Also:

DSL.schema(Name), DSL.setSchema(Name)

setSchema

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,TERADATA,VERTICA})
@NotNull RowCountQuery setSchema(Schema schema)

Set the current schema to a new value.

See Also:

DSL.setSchema(Schema)

set

@NotNull
@Support({AURORA_MYSQL,MEMSQL,MYSQL})
@NotNull RowCountQuery set(Name name,
                           Param<?> param)

Set a vendor specific flag to a new value.

See Also:

DSL.set(Name, Param)

createDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull CreateDatabaseFinalStep createDatabase(String database)

The CREATE DATABASE statement.

See Also:

DSL.createDatabase(String)

createDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull CreateDatabaseFinalStep createDatabase(Name database)

The CREATE DATABASE statement.

See Also:

DSL.createDatabase(Name)

createDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull CreateDatabaseFinalStep createDatabase(Catalog database)

The CREATE DATABASE statement.

See Also:

DSL.createDatabase(Catalog)

createDatabaseIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull CreateDatabaseFinalStep createDatabaseIfNotExists(String database)

The CREATE DATABASE IF NOT EXISTS statement.

See Also:

DSL.createDatabaseIfNotExists(String)

createDatabaseIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull CreateDatabaseFinalStep createDatabaseIfNotExists(Name database)

The CREATE DATABASE IF NOT EXISTS statement.

See Also:

DSL.createDatabaseIfNotExists(Name)

createDatabaseIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull CreateDatabaseFinalStep createDatabaseIfNotExists(Catalog database)

The CREATE DATABASE IF NOT EXISTS statement.

See Also:

DSL.createDatabaseIfNotExists(Catalog)

createDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull CreateDomainAsStep createDomain(String domain)

The CREATE DOMAIN statement.

See Also:

DSL.createDomain(String)

createDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull CreateDomainAsStep createDomain(Name domain)

The CREATE DOMAIN statement.

See Also:

DSL.createDomain(Name)

createDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull CreateDomainAsStep createDomain(Domain<?> domain)

The CREATE DOMAIN statement.

See Also:

DSL.createDomain(Domain)

createDomainIfNotExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,POSTGRES,SQLSERVER})
@NotNull CreateDomainAsStep createDomainIfNotExists(String domain)

The CREATE DOMAIN IF NOT EXISTS statement.

See Also:

DSL.createDomainIfNotExists(String)

createDomainIfNotExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,POSTGRES,SQLSERVER})
@NotNull CreateDomainAsStep createDomainIfNotExists(Name domain)

The CREATE DOMAIN IF NOT EXISTS statement.

See Also:

DSL.createDomainIfNotExists(Name)

createDomainIfNotExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,POSTGRES,SQLSERVER})
@NotNull CreateDomainAsStep createDomainIfNotExists(Domain<?> domain)

The CREATE DOMAIN IF NOT EXISTS statement.

See Also:

DSL.createDomainIfNotExists(Domain)

createSchema

@NotNull
@Support({AURORA_POSTGRES,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull CreateSchemaFinalStep createSchema(String schema)

The CREATE SCHEMA statement.

See Also:

DSL.createSchema(String)

createSchema

@NotNull
@Support({AURORA_POSTGRES,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull CreateSchemaFinalStep createSchema(Name schema)

The CREATE SCHEMA statement.

See Also:

DSL.createSchema(Name)

createSchema

@NotNull
@Support({AURORA_POSTGRES,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull CreateSchemaFinalStep createSchema(Schema schema)

The CREATE SCHEMA statement.

See Also:

DSL.createSchema(Schema)

createSchemaIfNotExists

@NotNull
@Support({AURORA_POSTGRES,DB2,H2,HANA,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull CreateSchemaFinalStep createSchemaIfNotExists(String schema)

The CREATE SCHEMA IF NOT EXISTS statement.

See Also:

DSL.createSchemaIfNotExists(String)

createSchemaIfNotExists

@NotNull
@Support({AURORA_POSTGRES,DB2,H2,HANA,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull CreateSchemaFinalStep createSchemaIfNotExists(Name schema)

The CREATE SCHEMA IF NOT EXISTS statement.

See Also:

DSL.createSchemaIfNotExists(Name)

createSchemaIfNotExists

@NotNull
@Support({AURORA_POSTGRES,DB2,H2,HANA,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull CreateSchemaFinalStep createSchemaIfNotExists(Schema schema)

The CREATE SCHEMA IF NOT EXISTS statement.

See Also:

DSL.createSchemaIfNotExists(Schema)

createSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull CreateSequenceFlagsStep createSequence(String sequence)

The CREATE SEQUENCE statement.

See Also:

DSL.createSequence(String)

createSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull CreateSequenceFlagsStep createSequence(Name sequence)

The CREATE SEQUENCE statement.

See Also:

DSL.createSequence(Name)

createSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull CreateSequenceFlagsStep createSequence(Sequence<?> sequence)

The CREATE SEQUENCE statement.

See Also:

DSL.createSequence(Sequence)

createSequenceIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull CreateSequenceFlagsStep createSequenceIfNotExists(String sequence)

The CREATE SEQUENCE IF NOT EXISTS statement.

See Also:

DSL.createSequenceIfNotExists(String)

createSequenceIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull CreateSequenceFlagsStep createSequenceIfNotExists(Name sequence)

The CREATE SEQUENCE IF NOT EXISTS statement.

See Also:

DSL.createSequenceIfNotExists(Name)

createSequenceIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull CreateSequenceFlagsStep createSequenceIfNotExists(Sequence<?> sequence)

The CREATE SEQUENCE IF NOT EXISTS statement.

See Also:

DSL.createSequenceIfNotExists(Sequence)

alterDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,POSTGRES})
@NotNull AlterDatabaseStep alterDatabase(String database)

The ALTER DATABASE statement.

See Also:

DSL.alterDatabase(String)

alterDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,POSTGRES})
@NotNull AlterDatabaseStep alterDatabase(Name database)

The ALTER DATABASE statement.

See Also:

DSL.alterDatabase(Name)

alterDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,POSTGRES})
@NotNull AlterDatabaseStep alterDatabase(Catalog database)

The ALTER DATABASE statement.

See Also:

DSL.alterDatabase(Catalog)

alterDatabaseIfExists

@NotNull
@Support({AURORA_POSTGRES,POSTGRES})
@NotNull AlterDatabaseStep alterDatabaseIfExists(String database)

The ALTER DATABASE IF EXISTS statement.

See Also:

DSL.alterDatabaseIfExists(String)

alterDatabaseIfExists

@NotNull
@Support({AURORA_POSTGRES,POSTGRES})
@NotNull AlterDatabaseStep alterDatabaseIfExists(Name database)

The ALTER DATABASE IF EXISTS statement.

See Also:

DSL.alterDatabaseIfExists(Name)

alterDatabaseIfExists

@NotNull
@Support({AURORA_POSTGRES,POSTGRES})
@NotNull AlterDatabaseStep alterDatabaseIfExists(Catalog database)

The ALTER DATABASE IF EXISTS statement.

See Also:

DSL.alterDatabaseIfExists(Catalog)

alterDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,HSQLDB,POSTGRES})
<T> @NotNull AlterDomainStep<T> alterDomain(String domain)

The ALTER DOMAIN statement.

See Also:

DSL.alterDomain(String)

alterDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,HSQLDB,POSTGRES})
<T> @NotNull AlterDomainStep<T> alterDomain(Name domain)

The ALTER DOMAIN statement.

See Also:

DSL.alterDomain(Name)

alterDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,HSQLDB,POSTGRES})
<T> @NotNull AlterDomainStep<T> alterDomain(Domain<T> domain)

The ALTER DOMAIN statement.

See Also:

DSL.alterDomain(Domain)

alterDomainIfExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,HSQLDB,POSTGRES})
<T> @NotNull AlterDomainStep<T> alterDomainIfExists(String domain)

The ALTER DOMAIN IF EXISTS statement.

See Also:

DSL.alterDomainIfExists(String)

alterDomainIfExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,HSQLDB,POSTGRES})
<T> @NotNull AlterDomainStep<T> alterDomainIfExists(Name domain)

The ALTER DOMAIN IF EXISTS statement.

See Also:

DSL.alterDomainIfExists(Name)

alterDomainIfExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,HSQLDB,POSTGRES})
<T> @NotNull AlterDomainStep<T> alterDomainIfExists(Domain<T> domain)

The ALTER DOMAIN IF EXISTS statement.

See Also:

DSL.alterDomainIfExists(Domain)

alterSchema

@NotNull
@Support({AURORA_POSTGRES,H2,HANA,HSQLDB,POSTGRES,VERTICA})
@NotNull AlterSchemaStep alterSchema(String schema)

The ALTER SCHEMA statement.

See Also:

DSL.alterSchema(String)

alterSchema

@NotNull
@Support({AURORA_POSTGRES,H2,HANA,HSQLDB,POSTGRES,VERTICA})
@NotNull AlterSchemaStep alterSchema(Name schema)

The ALTER SCHEMA statement.

See Also:

DSL.alterSchema(Name)

alterSchema

@NotNull
@Support({AURORA_POSTGRES,H2,HANA,HSQLDB,POSTGRES,VERTICA})
@NotNull AlterSchemaStep alterSchema(Schema schema)

The ALTER SCHEMA statement.

See Also:

DSL.alterSchema(Schema)

alterSchemaIfExists

@NotNull
@Support({H2,HANA})
@NotNull AlterSchemaStep alterSchemaIfExists(String schema)

The ALTER SCHEMA IF EXISTS statement.

See Also:

DSL.alterSchemaIfExists(String)

alterSchemaIfExists

@NotNull
@Support({H2,HANA})
@NotNull AlterSchemaStep alterSchemaIfExists(Name schema)

The ALTER SCHEMA IF EXISTS statement.

See Also:

DSL.alterSchemaIfExists(Name)

alterSchemaIfExists

@NotNull
@Support({H2,HANA})
@NotNull AlterSchemaStep alterSchemaIfExists(Schema schema)

The ALTER SCHEMA IF EXISTS statement.

See Also:

DSL.alterSchemaIfExists(Schema)

dropDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull DropDatabaseFinalStep dropDatabase(String database)

The DROP DATABASE statement.

See Also:

DSL.dropDatabase(String)

dropDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull DropDatabaseFinalStep dropDatabase(Name database)

The DROP DATABASE statement.

See Also:

DSL.dropDatabase(Name)

dropDatabase

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull DropDatabaseFinalStep dropDatabase(Catalog database)

The DROP DATABASE statement.

See Also:

DSL.dropDatabase(Catalog)

dropDatabaseIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull DropDatabaseFinalStep dropDatabaseIfExists(String database)

The DROP DATABASE IF EXISTS statement.

See Also:

DSL.dropDatabaseIfExists(String)

dropDatabaseIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull DropDatabaseFinalStep dropDatabaseIfExists(Name database)

The DROP DATABASE IF EXISTS statement.

See Also:

DSL.dropDatabaseIfExists(Name)

dropDatabaseIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER})
@NotNull DropDatabaseFinalStep dropDatabaseIfExists(Catalog database)

The DROP DATABASE IF EXISTS statement.

See Also:

DSL.dropDatabaseIfExists(Catalog)

dropDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull DropDomainCascadeStep dropDomain(String domain)

The DROP DOMAIN statement.

See Also:

DSL.dropDomain(String)

dropDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull DropDomainCascadeStep dropDomain(Name domain)

The DROP DOMAIN statement.

See Also:

DSL.dropDomain(Name)

dropDomain

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull DropDomainCascadeStep dropDomain(Domain<?> domain)

The DROP DOMAIN statement.

See Also:

DSL.dropDomain(Domain)

dropDomainIfExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull DropDomainCascadeStep dropDomainIfExists(String domain)

The DROP DOMAIN IF EXISTS statement.

See Also:

DSL.dropDomainIfExists(String)

dropDomainIfExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull DropDomainCascadeStep dropDomainIfExists(Name domain)

The DROP DOMAIN IF EXISTS statement.

See Also:

DSL.dropDomainIfExists(Name)

dropDomainIfExists

@NotNull
@Support({AURORA_POSTGRES,FIREBIRD,H2,HSQLDB,POSTGRES,SQLSERVER})
@NotNull DropDomainCascadeStep dropDomainIfExists(Domain<?> domain)

The DROP DOMAIN IF EXISTS statement.

See Also:

DSL.dropDomainIfExists(Domain)

dropSchema

@NotNull
@Support({AURORA_POSTGRES,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull DropSchemaStep dropSchema(String schema)

The DROP SCHEMA statement.

See Also:

DSL.dropSchema(String)

dropSchema

@NotNull
@Support({AURORA_POSTGRES,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull DropSchemaStep dropSchema(Name schema)

The DROP SCHEMA statement.

See Also:

DSL.dropSchema(Name)

dropSchema

@NotNull
@Support({AURORA_POSTGRES,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull DropSchemaStep dropSchema(Schema schema)

The DROP SCHEMA statement.

See Also:

DSL.dropSchema(Schema)

dropSchemaIfExists

@NotNull
@Support({AURORA_POSTGRES,DB2,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull DropSchemaStep dropSchemaIfExists(String schema)

The DROP SCHEMA IF EXISTS statement.

See Also:

DSL.dropSchemaIfExists(String)

dropSchemaIfExists

@NotNull
@Support({AURORA_POSTGRES,DB2,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull DropSchemaStep dropSchemaIfExists(Name schema)

The DROP SCHEMA IF EXISTS statement.

See Also:

DSL.dropSchemaIfExists(Name)

dropSchemaIfExists

@NotNull
@Support({AURORA_POSTGRES,DB2,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER,VERTICA})
@NotNull DropSchemaStep dropSchemaIfExists(Schema schema)

The DROP SCHEMA IF EXISTS statement.

See Also:

DSL.dropSchemaIfExists(Schema)

dropSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull DropSequenceFinalStep dropSequence(String sequence)

The DROP SEQUENCE statement.

See Also:

DSL.dropSequence(String)

dropSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull DropSequenceFinalStep dropSequence(Name sequence)

The DROP SEQUENCE statement.

See Also:

DSL.dropSequence(Name)

dropSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull DropSequenceFinalStep dropSequence(Sequence<?> sequence)

The DROP SEQUENCE statement.

See Also:

DSL.dropSequence(Sequence)

dropSequenceIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull DropSequenceFinalStep dropSequenceIfExists(String sequence)

The DROP SEQUENCE IF EXISTS statement.

See Also:

DSL.dropSequenceIfExists(String)

dropSequenceIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull DropSequenceFinalStep dropSequenceIfExists(Name sequence)

The DROP SEQUENCE IF EXISTS statement.

See Also:

DSL.dropSequenceIfExists(Name)

dropSequenceIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull DropSequenceFinalStep dropSequenceIfExists(Sequence<?> sequence)

The DROP SEQUENCE IF EXISTS statement.

See Also:

DSL.dropSequenceIfExists(Sequence)

grant

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
@NotNull GrantOnStep grant(Privilege privileges)

The GRANT statement.

See Also:

DSL.grant(Privilege)

grant

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
@NotNull GrantOnStep grant(Privilege... privileges)

The GRANT statement.

See Also:

DSL.grant(Privilege...)

grant

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
@NotNull GrantOnStep grant(Collection<? extends Privilege> privileges)

The GRANT statement.

See Also:

DSL.grant(Collection)

revoke

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
@NotNull RevokeOnStep revoke(Privilege privileges)

The REVOKE statement.

See Also:

DSL.revoke(Privilege)

revoke

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
@NotNull RevokeOnStep revoke(Privilege... privileges)

The REVOKE statement.

See Also:

DSL.revoke(Privilege...)

revoke

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DERBY,H2,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER})
@NotNull RevokeOnStep revoke(Collection<? extends Privilege> privileges)

The REVOKE statement.

See Also:

DSL.revoke(Collection)

revokeGrantOptionFor

@NotNull
@Support({ASE,AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
@NotNull RevokeOnStep revokeGrantOptionFor(Privilege privileges)

The REVOKE GRANT OPTION FOR statement.

See Also:

DSL.revokeGrantOptionFor(Privilege)

revokeGrantOptionFor

@NotNull
@Support({ASE,AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
@NotNull RevokeOnStep revokeGrantOptionFor(Privilege... privileges)

The REVOKE GRANT OPTION FOR statement.

See Also:

DSL.revokeGrantOptionFor(Privilege...)

revokeGrantOptionFor

@NotNull
@Support({ASE,AURORA_POSTGRES,HSQLDB,ORACLE,POSTGRES,SQLSERVER})
@NotNull RevokeOnStep revokeGrantOptionFor(Collection<? extends Privilege> privileges)

The REVOKE GRANT OPTION FOR statement.

See Also:

DSL.revokeGrantOptionFor(Collection)

commentOnTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnTable(String tableName)

Create a new DSL COMMENT ON TABLE statement.

See Also:

DSL.commentOnTable(String), AlterTableStep.comment(Comment)

commentOnTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnTable(Name tableName)

Create a new DSL COMMENT ON TABLE statement.

See Also:

DSL.commentOnTable(Name), AlterTableStep.comment(Comment)

commentOnTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnTable(Table<?> table)

Create a new DSL COMMENT ON TABLE statement.

See Also:

DSL.commentOnTable(Table), AlterTableStep.comment(Comment)

commentOnView

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnView(String viewName)

Create a new DSL COMMENT ON VIEW statement.

See Also:

DSL.commentOnView(String), AlterViewStep.comment(Comment)

commentOnView

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnView(Name viewName)

Create a new DSL COMMENT ON VIEW statement.

See Also:

DSL.commentOnView(Name), AlterViewStep.comment(Comment)

commentOnView

@NotNull
@Support({AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnView(Table<?> view)

Create a new DSL COMMENT ON VIEW statement.

See Also:

DSL.commentOnView(Table), AlterViewStep.comment(Comment)

commentOnColumn

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnColumn(Name columnName)

Create a new DSL COMMENT ON COLUMN statement.

See Also:

DSL.commentOnColumn(Name)

commentOnColumn

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,MARIADB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CommentOnIsStep commentOnColumn(Field<?> field)

Create a new DSL COMMENT ON COLUMN statement.

See Also:

DSL.commentOnColumn(Field)

createTable

@NotNull
@Support
@NotNull CreateTableColumnStep createTable(String table)

Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTable(String)

createTable

@NotNull
@Support
@NotNull CreateTableColumnStep createTable(Name table)

Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTable(Name)

createTable

@NotNull
@Support
@NotNull CreateTableColumnStep createTable(Table<?> table)

Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTable(Table)

createTableIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull CreateTableColumnStep createTableIfNotExists(String table)

Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTableIfNotExists(String)

createTableIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull CreateTableColumnStep createTableIfNotExists(Name table)

Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTableIfNotExists(Name)

createTableIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull CreateTableColumnStep createTableIfNotExists(Table<?> table)

Create a new DSL CREATE TABLE statement.

See Also:

DSL.createTableIfNotExists(Table)

createTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull CreateTableColumnStep createTemporaryTable(String table)

Create a new DSL CREATE TEMPORARY TABLE statement.

See Also:

DSL.createTemporaryTable(String)

createTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull CreateTableColumnStep createTemporaryTable(Name table)

Create a new DSL CREATE TEMPORARY TABLE statement.

See Also:

DSL.createTemporaryTable(Name)

createTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull CreateTableColumnStep createTemporaryTable(Table<?> table)

Create a new DSL CREATE TEMPORARY TABLE statement.

See Also:

DSL.createTemporaryTable(Table)

createTemporaryTableIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,VERTICA})
@NotNull CreateTableColumnStep createTemporaryTableIfNotExists(String table)

Create a new DSL CREATE TEMPORARY TABLE IF NOT EXISTS statement.

See Also:

DSL.createTemporaryTableIfNotExists(String)

createTemporaryTableIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,VERTICA})
@NotNull CreateTableColumnStep createTemporaryTableIfNotExists(Name table)

Create a new DSL CREATE TEMPORARY TABLE IF NOT EXISTS statement.

See Also:

DSL.createTemporaryTableIfNotExists(Name)

createTemporaryTableIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,VERTICA})
@NotNull CreateTableColumnStep createTemporaryTableIfNotExists(Table<?> table)

Create a new DSL CREATE TEMPORARY TABLE IF NOT EXISTS statement.

See Also:

DSL.createTemporaryTableIfNotExists(Table)

createGlobalTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull CreateTableColumnStep createGlobalTemporaryTable(String table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:

DSL.createGlobalTemporaryTable(String)

createGlobalTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull CreateTableColumnStep createGlobalTemporaryTable(Name table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:

DSL.createGlobalTemporaryTable(Name)

createGlobalTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull CreateTableColumnStep createGlobalTemporaryTable(Table<?> table)

Create a new DSL CREATE GLOBAL TEMPORARY TABLE statement.

See Also:

DSL.createGlobalTemporaryTable(Table)

createView

@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(String view,
                                             String... fields)

Create a new DSL CREATE VIEW statement.

See Also:

DSL.createView(String, String...)

createView

@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(Name view,
                                             Name... fields)

Create a new DSL CREATE VIEW statement.

See Also:

DSL.createView(Name, Name...)

createView

@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(Table<?> view,
                                             Field<?>... fields)

Create a new DSL CREATE VIEW statement.

See Also:

DSL.createView(Table, Field...)

createView

@Deprecated
@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(String view,
                                             Function<? super Field<?>,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView

@Deprecated
@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(String view,
                                             BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView

@Deprecated
@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(Name view,
                                             Function<? super Field<?>,? extends Name> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView

@Deprecated
@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(Name view,
                                             BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView

@Deprecated
@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(Table<?> view,
                                             Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createView

@Deprecated
@NotNull
@Support
@NotNull CreateViewAsStep<Record> createView(Table<?> view,
                                             BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createView(String, String...)

createOrReplaceView

@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(String view,
                                                      String... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:

DSL.createOrReplaceView(String, String...)

createOrReplaceView

@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(Name view,
                                                      Name... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:

DSL.createOrReplaceView(Name, Name...)

createOrReplaceView

@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(Table<?> view,
                                                      Field<?>... fields)

Create a new DSL CREATE OR REPLACE VIEW statement.

See Also:

DSL.createOrReplaceView(Table, Field...)

createOrReplaceView

@Deprecated
@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(String view,
                                                      Function<? super Field<?>,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Deprecated
@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(String view,
                                                      BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Deprecated
@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(Name view,
                                                      Function<? super Field<?>,? extends Name> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Deprecated
@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(Name view,
                                                      BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Deprecated
@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(Table<?> view,
                                                      Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createOrReplaceView(String, String...)

createOrReplaceView

@Deprecated
@NotNull
@Support({ASE_16_0,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,MARIADB,MYSQL,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull CreateViewAsStep<Record> createOrReplaceView(Table<?> view,
                                                      BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE OR REPLACE VIEW statement.

This works like createOrReplaceView(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createOrReplaceView(String, String...)

createViewIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(String view,
                                                        String... fields)

Create a new DSL CREATE VIEW statement.

See Also:

DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(Name view,
                                                        Name... fields)

Create a new DSL CREATE VIEW statement.

See Also:

DSL.createViewIfNotExists(Name, Name...)

createViewIfNotExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(Table<?> view,
                                                        Field<?>... fields)

Create a new DSL CREATE VIEW statement.

See Also:

DSL.createViewIfNotExists(Table, Field...)

createViewIfNotExists

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(String view,
                                                        Function<? super Field<?>,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(String view,
                                                        BiFunction<? super Field<?>,? super Integer,? extends String> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(String, String...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(Name view,
                                                        Function<? super Field<?>,? extends Name> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(Name view,
                                                        BiFunction<? super Field<?>,? super Integer,? extends Name> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Name, Name...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(Table<?> view,
                                                        Function<? super Field<?>,? extends Field<?>> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createViewIfNotExists(String, String...)

createViewIfNotExists

@Deprecated
@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateViewAsStep<Record> createViewIfNotExists(Table<?> view,
                                                        BiFunction<? super Field<?>,? super Integer,? extends Field<?>> fieldNameFunction)

Deprecated.

- 3.14.0 - [#10156] - These methods will be removed without replacement from a future jOOQ. They offer convenience that is unidiomatic for jOOQ's DSL, without offering functionality that would not be possible otherwise - yet they add complexity in jOOQ's internals.

Create a new DSL CREATE VIEW statement.

This works like createViewIfNotExists(Table, Field...) except that the view's field names are derived from the view's Select statement using a function.

See Also:

DSL.createViewIfNotExists(String, String...)

createType

@NotNull
@Support({H2,POSTGRES})
@NotNull CreateTypeStep createType(String type)

Create a new DSL CREATE TYPE statement.

See Also:

DSL.createType(String)

createType

@NotNull
@Support({H2,POSTGRES})
@NotNull CreateTypeStep createType(Name type)

Create a new DSL CREATE TYPE statement.

See Also:

DSL.createType(Name)

alterType

@NotNull
@Support(POSTGRES)
@NotNull AlterTypeStep alterType(String type)

Create a new DSL ALTER TYPE statement.

See Also:

DSL.alterType(String)

alterType

@NotNull
@Support(POSTGRES)
@NotNull AlterTypeStep alterType(Name type)

Create a new DSL ALTER TYPE statement.

See Also:

DSL.alterType(Name)

dropType

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropType(String type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(String)

dropType

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropType(Name type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(Name)

dropType

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropType(String... type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(String...)

dropType

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropType(Name... type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(Name...)

dropType

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropType(Collection<?> type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropType(Collection)

dropTypeIfExists

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropTypeIfExists(String type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(String)

dropTypeIfExists

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropTypeIfExists(Name type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(Name)

dropTypeIfExists

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropTypeIfExists(String... type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(String...)

dropTypeIfExists

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropTypeIfExists(Name... type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(Name...)

dropTypeIfExists

@NotNull
@Support({H2,POSTGRES})
@NotNull DropTypeStep dropTypeIfExists(Collection<?> type)

Create a new DSL DROP TYPE statement.

See Also:

DSL.dropTypeIfExists(Collection)

createIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createIndex()

Create a new DSL CREATE INDEX statement.

See Also:

DSL.createIndex()

createIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createIndex(String index)

Create a new DSL CREATE INDEX statement.

See Also:

DSL.createIndex(String)

createIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createIndex(Name index)

Create a new DSL CREATE INDEX statement.

See Also:

DSL.createIndex(Name)

createIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createIndex(Index index)

Create a new DSL CREATE INDEX statement.

See Also:

DSL.createIndex(Index)

createIndexIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateIndexStep createIndexIfNotExists(String index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:

DSL.createIndexIfNotExists(String)

createIndexIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateIndexStep createIndexIfNotExists(Name index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:

DSL.createIndexIfNotExists(Name)

createIndexIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateIndexStep createIndexIfNotExists(Index index)

Create a new DSL CREATE INDEX IF NOT EXISTS statement.

See Also:

DSL.createIndexIfNotExists(Index)

createUniqueIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createUniqueIndex()

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createUniqueIndex()

createUniqueIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createUniqueIndex(String index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createIndex(String)

createUniqueIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createUniqueIndex(Name index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createIndex(Name)

createUniqueIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull CreateIndexStep createUniqueIndex(Index index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createIndex(Index)

createUniqueIndexIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateIndexStep createUniqueIndexIfNotExists(String index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createIndex(String)

createUniqueIndexIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateIndexStep createUniqueIndexIfNotExists(Name index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createIndex(Name)

createUniqueIndexIfNotExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HANA,HSQLDB,ORACLE,POSTGRES,SQLITE,SQLSERVER,SYBASE})
@NotNull CreateIndexStep createUniqueIndexIfNotExists(Index index)

Create a new DSL CREATE UNIQUE INDEX statement.

See Also:

DSL.createIndex(Index)

alterSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull AlterSequenceStep<BigInteger> alterSequence(String sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:

DSL.alterSequence(String)

alterSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull AlterSequenceStep<BigInteger> alterSequence(Name sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:

DSL.alterSequence(Name)

alterSequence

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> @NotNull AlterSequenceStep<T> alterSequence(Sequence<T> sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:

DSL.alterSequence(Sequence)

alterSequenceIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,H2,MARIADB_10_3,ORACLE,POSTGRES})
@NotNull AlterSequenceStep<BigInteger> alterSequenceIfExists(String sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:

DSL.alterSequenceIfExists(String)

alterSequenceIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,H2,MARIADB_10_3,ORACLE,POSTGRES})
@NotNull AlterSequenceStep<BigInteger> alterSequenceIfExists(Name sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:

DSL.alterSequenceIfExists(Name)

alterSequenceIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,H2,MARIADB_10_3,ORACLE,POSTGRES})
<T extends Number> @NotNull AlterSequenceStep<T> alterSequenceIfExists(Sequence<T> sequence)

Create a new DSL ALTER SEQUENCE statement.

See Also:

DSL.alterSequenceIfExists(Sequence)

alterTable

@NotNull
@Support
@NotNull AlterTableStep alterTable(String table)

Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTable(String)

alterTable

@NotNull
@Support
@NotNull AlterTableStep alterTable(Name table)

Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTable(Name)

alterTable

@NotNull
@Support
@NotNull AlterTableStep alterTable(Table<?> table)

Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTable(Table)

alterTableIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,H2,HANA,MARIADB,ORACLE,POSTGRES,SQLSERVER})
@NotNull AlterTableStep alterTableIfExists(String table)

Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTableIfExists(String)

alterTableIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,H2,HANA,MARIADB,ORACLE,POSTGRES,SQLSERVER})
@NotNull AlterTableStep alterTableIfExists(Name table)

Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTableIfExists(Name)

alterTableIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,H2,HANA,MARIADB,ORACLE,POSTGRES,SQLSERVER})
@NotNull AlterTableStep alterTableIfExists(Table<?> table)

Create a new DSL ALTER TABLE statement.

See Also:

DSL.alterTableIfExists(Table)

alterView

@NotNull
@Support({ASE,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull AlterViewStep alterView(String view)

Create a new DSL ALTER VIEW statement.

See Also:

DSL.alterView(String)

alterView

@NotNull
@Support({ASE,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull AlterViewStep alterView(Name view)

Create a new DSL ALTER VIEW statement.

See Also:

DSL.alterView(Name)

alterView

@NotNull
@Support({ASE,AURORA_POSTGRES,COCKROACHDB,DB2,FIREBIRD,H2,HSQLDB,ORACLE,POSTGRES,SQLSERVER,TERADATA,VERTICA})
@NotNull AlterViewStep alterView(Table<?> view)

Create a new DSL ALTER VIEW statement.

See Also:

DSL.alterView(Table)

alterViewIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,H2,ORACLE,POSTGRES,SQLSERVER})
@NotNull AlterViewStep alterViewIfExists(String view)

Create a new DSL ALTER VIEW statement.

See Also:

DSL.alterViewIfExists(String)

alterViewIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,H2,ORACLE,POSTGRES,SQLSERVER})
@NotNull AlterViewStep alterViewIfExists(Name view)

Create a new DSL ALTER VIEW statement.

See Also:

DSL.alterViewIfExists(Name)

alterViewIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,H2,ORACLE,POSTGRES,SQLSERVER})
@NotNull AlterViewStep alterViewIfExists(Table<?> view)

Create a new DSL ALTER VIEW statement.

See Also:

DSL.alterViewIfExists(Table)

alterIndex

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
@NotNull AlterIndexOnStep alterIndex(String index)

Create a new DSL ALTER INDEX statement.

See Also:

DSL.alterIndex(String)

alterIndex

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
@NotNull AlterIndexOnStep alterIndex(Name index)

Create a new DSL ALTER INDEX statement.

See Also:

DSL.alterIndex(Name)

alterIndex

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,DB2,DERBY,H2,HANA,HSQLDB,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
@NotNull AlterIndexOnStep alterIndex(Index index)

Create a new DSL ALTER INDEX statement.

See Also:

DSL.alterIndex(Name)

alterIndexIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,H2,HANA,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
@NotNull AlterIndexStep alterIndexIfExists(String index)

Create a new DSL ALTER INDEX statement.

See Also:

DSL.alterIndexIfExists(String)

alterIndexIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,H2,HANA,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
@NotNull AlterIndexStep alterIndexIfExists(Name index)

Create a new DSL ALTER INDEX statement.

See Also:

DSL.alterIndexIfExists(Name)

alterIndexIfExists

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,DB2,H2,HANA,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLSERVER2016})
@NotNull AlterIndexStep alterIndexIfExists(Index index)

Create a new DSL ALTER INDEX statement.

See Also:

DSL.alterIndexIfExists(Name)

dropView

@NotNull
@Support
@NotNull DropViewFinalStep dropView(String view)

Create a new DSL DROP VIEW statement.

See Also:

DSL.dropView(String)

dropView

@NotNull
@Support
@NotNull DropViewFinalStep dropView(Name view)

Create a new DSL DROP VIEW statement.

See Also:

DSL.dropView(Name)

dropView

@NotNull
@Support
@NotNull DropViewFinalStep dropView(Table<?> view)

Create a new DSL DROP VIEW statement.

See Also:

DSL.dropView(Table)

dropViewIfExists

@NotNull
@Support({ACCESS,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull DropViewFinalStep dropViewIfExists(String view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropViewIfExists(String)

dropViewIfExists

@NotNull
@Support({ACCESS,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull DropViewFinalStep dropViewIfExists(Name view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropViewIfExists(Name)

dropViewIfExists

@NotNull
@Support({ACCESS,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull DropViewFinalStep dropViewIfExists(Table<?> view)

Create a new DSL DROP VIEW IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropViewIfExists(Table)

dropTable

@NotNull
@Support
@NotNull DropTableStep dropTable(String table)

Create a new DSL DROP TABLE statement.

See Also:

DSL.dropTable(String)

dropTable

@NotNull
@Support
@NotNull DropTableStep dropTable(Name table)

Create a new DSL DROP TABLE statement.

See Also:

DSL.dropTable(Name)

dropTable

@NotNull
@Support
@NotNull DropTableStep dropTable(Table<?> table)

Create a new DSL DROP TABLE statement.

See Also:

DSL.dropTable(Table)

dropTableIfExists

@NotNull
@Support({ACCESS,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull DropTableStep dropTableIfExists(String table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropTableIfExists(String)

dropTableIfExists

@NotNull
@Support({ACCESS,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull DropTableStep dropTableIfExists(Name table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropTableIfExists(Name)

dropTableIfExists

@NotNull
@Support({ACCESS,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,VERTICA})
@NotNull DropTableStep dropTableIfExists(Table<?> table)

Create a new DSL DROP TABLE IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropTableIfExists(Table)

dropTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull DropTableStep dropTemporaryTable(String table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:

DSL.dropTemporaryTable(String)

dropTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull DropTableStep dropTemporaryTable(Name table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:

DSL.dropTemporaryTable(Name)

dropTemporaryTable

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,REDSHIFT,TERADATA,VERTICA})
@NotNull DropTableStep dropTemporaryTable(Table<?> table)

Create a new DSL DROP TEMPORARY TABLE statement.

See Also:

DSL.dropTemporaryTable(Table)

dropTemporaryTableIfExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,VERTICA})
@NotNull DropTableStep dropTemporaryTableIfExists(String table)

Create a new DSL DROP TEMPORARY TABLE IF EXISTS statement.

See Also:

DSL.dropTemporaryTableIfExists(String)

dropTemporaryTableIfExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,VERTICA})
@NotNull DropTableStep dropTemporaryTableIfExists(Name table)

Create a new DSL DROP TEMPORARY TABLE IF EXISTS statement.

See Also:

DSL.dropTemporaryTableIfExists(Name)

dropTemporaryTableIfExists

@NotNull
@Support({AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,FIREBIRD,HANA,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,VERTICA})
@NotNull DropTableStep dropTemporaryTableIfExists(Table<?> table)

Create a new DSL DROP TEMPORARY TABLE IF EXISTS statement.

See Also:

DSL.dropTemporaryTableIfExists(Table)

dropIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull DropIndexOnStep dropIndex(String index)

Create a new DSL DROP INDEX statement.

See Also:

DSL.dropIndex(String)

dropIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull DropIndexOnStep dropIndex(Name index)

Create a new DSL DROP INDEX statement.

See Also:

DSL.dropIndex(Name)

dropIndex

@NotNull
@Support({ACCESS,ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE,TERADATA})
@NotNull DropIndexOnStep dropIndex(Index index)

Create a new DSL DROP INDEX statement.

See Also:

DSL.dropIndex(Name)

dropIndexIfExists

@NotNull
@Support({ACCESS,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull DropIndexOnStep dropIndexIfExists(String index)

Create a new DSL DROP INDEX IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropIndexIfExists(String)

dropIndexIfExists

@NotNull
@Support({ACCESS,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull DropIndexOnStep dropIndexIfExists(Name index)

Create a new DSL DROP INDEX IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropIndexIfExists(Name)

dropIndexIfExists

@NotNull
@Support({ACCESS,AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB,ORACLE,POSTGRES,SQLDATAWAREHOUSE,SQLITE,SQLSERVER,SYBASE})
@NotNull DropIndexOnStep dropIndexIfExists(Index index)

Create a new DSL DROP INDEX IF EXISTS statement.

If your database doesn't natively support IF EXISTS, this is emulated by catching (and ignoring) the relevant SQLException.

See Also:

DSL.dropIndexIfExists(Name)

truncate

@NotNull
@Support
@NotNull TruncateIdentityStep<Record> truncate(String table)

Create a new DSL truncate statement.

Synonym for truncateTable(String)

truncate

@NotNull
@Support
@NotNull TruncateIdentityStep<Record> truncate(Name table)

Create a new DSL truncate statement.

Synonym for truncateTable(Name)

truncate

@NotNull
@Support
<R extends Record> @NotNull TruncateIdentityStep<R> truncate(Table<R> table)

Create a new DSL truncate statement.

Synonym for truncateTable(Table)

truncateTable

@NotNull
@Support
@NotNull TruncateIdentityStep<Record> truncateTable(String table)

Create a new DSL truncate statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.truncate(table)
       .execute();
 

Emulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:

• SQLDialect.FIREBIRD
• SQLDialect.INGRES
• SQLDialect.SQLITE

Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:

 create.truncate(table)
       .restartIdentity()
       .cascade()
       .execute();
 

These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.

See Also:

truncate(Table)

truncateTable

@NotNull
@Support
@NotNull TruncateIdentityStep<Record> truncateTable(Name table)

Create a new DSL truncate statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.truncate(table)
       .execute();
 

Emulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:

• SQLDialect.FIREBIRD
• SQLDialect.INGRES
• SQLDialect.SQLITE

Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:

 create.truncate(table)
       .restartIdentity()
       .cascade()
       .execute();
 

These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.

See Also:

truncate(Name)

truncateTable

@NotNull
@Support
<R extends Record> @NotNull TruncateIdentityStep<R> truncateTable(Table<R> table)

Create a new DSL truncate statement.

Example:

 DSLContext create = DSL.using(configuration);

 create.truncate(table)
       .execute();
 

Emulation of TRUNCATE

Most dialects implement the TRUNCATE statement. If it is not supported, it is emulated using an equivalent DELETE statement. This is particularly true for these dialects:

• SQLDialect.FIREBIRD
• SQLDialect.INGRES
• SQLDialect.SQLITE

Vendor-specific extensions of TRUNCATE

Some statements also support extensions of the TRUNCATE statement, such as Postgres:

 create.truncate(table)
       .restartIdentity()
       .cascade()
       .execute();
 

These vendor-specific extensions are currently not emulated for those dialects that do not support them natively.

lastID

@NotNull
@Support({ASE,AURORA_MYSQL,AURORA_POSTGRES,COCKROACHDB,CUBRID,DERBY,H2,HSQLDB,INFORMIX,INGRES,MARIADB,MEMSQL,MYSQL,POSTGRES,SQLITE,SQLSERVER,SYBASE})
@NotNull BigInteger lastID()
                    throws DataAccessException

Retrieve the last inserted ID.

This is implemented for the following dialects:

• SQLDialect.ACCESS: Using @@identity
• SQLDialect.ASE: Using @@identity
• SQLDialect.DERBY: Using identity_val_local()
• SQLDialect.H2: Using identity()
• SQLDialect.HSQLDB: Using identity()
• SQLDialect.INFORMIX: Using dbinfo('sqlca.sqlerrd1')
• SQLDialect.INGRES: Using last_identity()
• SQLDialect.MARIADB: Using last_insert_id()
• SQLDialect.MYSQL: Using last_insert_id()
• SQLDialect.POSTGRES: Using lastval()
• SQLDialect.SQLITE: Using last_insert_rowid()
• SQLDialect.SQLSERVER: Using @@identity
• SQLDialect.SYBASE: Using @@identity
• SQLDialect.VERTICA: Using last_insert_id()

Returns:

The last inserted ID. This may be null in some dialects, if no such number is available.

Throws:

DataAccessException - if something went wrong executing the query

nextval

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull BigInteger nextval(String sequence)
                     throws DataAccessException

Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:

DataAccessException - if something went wrong executing the query

nextval

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull BigInteger nextval(Name sequence)
                     throws DataAccessException

Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:

DataAccessException - if something went wrong executing the query

nextval

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> T nextval(Sequence<T> sequence)
                      throws DataAccessException

Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:

DataAccessException - if something went wrong executing the query

nextvals

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,DERBY,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> @NotNull List<T> nextvals(Sequence<T> sequence,
                                             int size)
                                      throws DataAccessException

Convenience method to fetch several NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

This is done using DSL.generateSeries(int, int).

Throws:

DataAccessException - if something went wrong executing the query

currval

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull BigInteger currval(String sequence)
                     throws DataAccessException

Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:

DataAccessException - if something went wrong executing the query

currval

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
@NotNull BigInteger currval(Name sequence)
                     throws DataAccessException

Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:

DataAccessException - if something went wrong executing the query

currval

@NotNull
@Support({AURORA_POSTGRES,COCKROACHDB,CUBRID,DB2,FIREBIRD,H2,HANA,HSQLDB,INFORMIX,INGRES,MARIADB_10_3,ORACLE,POSTGRES,SQLSERVER2012,SYBASE,VERTICA})
<T extends Number> T currval(Sequence<T> sequence)
                      throws DataAccessException

Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.

Throws:

DataAccessException - if something went wrong executing the query

newRecord

@NotNull
<R extends UDTRecord<R>> R newRecord(UDT<R> type)

Create a new UDTRecord.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

R - The generic record type

Parameters:

type - The UDT describing records of type <R>

Returns:

The new record

newRecord

@NotNull
<R extends Record> R newRecord(Table<R> table)

Create a new Record that can be inserted into the corresponding table.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

R - The generic record type

Parameters:

table - The table holding records of type <R>

Returns:

The new record

newRecord

@NotNull
<R extends Record> R newRecord(Table<R> table,
                               Object source)

Create a new pre-filled Record that can be inserted into the corresponding table.

This performs roughly the inverse operation of Record.into(Class)

The resulting record will have its internal "changed" flags set to true for all values. This means that UpdatableRecord.store() will perform an INSERT statement. If you wish to store the record using an UPDATE statement, use executeUpdate(UpdatableRecord) instead.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

R - The generic record type

Parameters:

table - The table holding records of type <R>

source - The source to be used to fill the new record

Returns:

The new record

Throws:

MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

See Also:

Record.from(Object), Record.into(Class)

newRecord

@NotNull
@NotNull Record newRecord(Field<?>... fields)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newRecord

@NotNull
@NotNull Record newRecord(Collection<? extends Field<?>> fields)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newRecord

@NotNull
<T1> @NotNull Record1<T1> newRecord(Field<T1> field1)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2> @NotNull Record2<T1,T2> newRecord(Field<T1> field1,
                                                      Field<T2> field2)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3> @NotNull Record3<T1,T2,T3> newRecord(Field<T1> field1,
                                                                        Field<T2> field2,
                                                                        Field<T3> field3)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4> @NotNull Record4<T1,T2,T3,T4> newRecord(Field<T1> field1,
                                                                                          Field<T2> field2,
                                                                                          Field<T3> field3,
                                                                                          Field<T4> field4)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5> @NotNull Record5<T1,T2,T3,T4,T5> newRecord(Field<T1> field1,
                                                                                                            Field<T2> field2,
                                                                                                            Field<T3> field3,
                                                                                                            Field<T4> field4,
                                                                                                            Field<T5> field5)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6> @NotNull Record6<T1,T2,T3,T4,T5,T6> newRecord(Field<T1> field1,
                                                                                                                              Field<T2> field2,
                                                                                                                              Field<T3> field3,
                                                                                                                              Field<T4> field4,
                                                                                                                              Field<T5> field5,
                                                                                                                              Field<T6> field6)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7> @NotNull Record7<T1,T2,T3,T4,T5,T6,T7> newRecord(Field<T1> field1,
                                                                                                                                                Field<T2> field2,
                                                                                                                                                Field<T3> field3,
                                                                                                                                                Field<T4> field4,
                                                                                                                                                Field<T5> field5,
                                                                                                                                                Field<T6> field6,
                                                                                                                                                Field<T7> field7)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8> @NotNull Record8<T1,T2,T3,T4,T5,T6,T7,T8> newRecord(Field<T1> field1,
                                                                                                                                                                  Field<T2> field2,
                                                                                                                                                                  Field<T3> field3,
                                                                                                                                                                  Field<T4> field4,
                                                                                                                                                                  Field<T5> field5,
                                                                                                                                                                  Field<T6> field6,
                                                                                                                                                                  Field<T7> field7,
                                                                                                                                                                  Field<T8> field8)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9> @NotNull Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9> newRecord(Field<T1> field1,
                                                                                                                                                                                    Field<T2> field2,
                                                                                                                                                                                    Field<T3> field3,
                                                                                                                                                                                    Field<T4> field4,
                                                                                                                                                                                    Field<T5> field5,
                                                                                                                                                                                    Field<T6> field6,
                                                                                                                                                                                    Field<T7> field7,
                                                                                                                                                                                    Field<T8> field8,
                                                                                                                                                                                    Field<T9> field9)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> @NotNull Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> newRecord(Field<T1> field1,
                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                         Field<T10> field10)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> @NotNull Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> newRecord(Field<T1> field1,
                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                             Field<T11> field11)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> @NotNull Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                 Field<T12> field12)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> @NotNull Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                     Field<T13> field13)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> @NotNull Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                         Field<T14> field14)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> @NotNull Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                                                             Field<T13> field13,
                                                                                                                                                                                                                                                                                                             Field<T14> field14,
                                                                                                                                                                                                                                                                                                             Field<T15> field15)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> @NotNull Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                 Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                 Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                 Field<T16> field16)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> @NotNull Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                     Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                     Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                     Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                     Field<T17> field17)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> @NotNull Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                         Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                         Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                         Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                         Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                         Field<T18> field18)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> @NotNull Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                             Field<T19> field19)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> @NotNull Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T20> field20)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> @NotNull Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                     Field<T21> field21)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newRecord

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> @NotNull Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> newRecord(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T22> field22)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new record

newResult

@NotNull
<R extends Record> @NotNull Result<R> newResult(Table<R> table)

Create a new empty Result.

The result is attached to this Configuration by default. This result can be used as a container for records.

Type Parameters:

R - The generic record type

Parameters:

table - The table holding records of type <R>

Returns:

The new result

newResult

@NotNull
@NotNull Result<Record> newResult(Field<?>... fields)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newResult

@NotNull
@NotNull Result<Record> newResult(Collection<? extends Field<?>> fields)

Create a new empty Record.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

fields - The fields defining the Record type

Returns:

The new record

newResult

@NotNull
<T1> @NotNull Result<Record1<T1>> newResult(Field<T1> field1)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2> @NotNull Result<Record2<T1,T2>> newResult(Field<T1> field1,
                                                              Field<T2> field2)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3> @NotNull Result<Record3<T1,T2,T3>> newResult(Field<T1> field1,
                                                                                Field<T2> field2,
                                                                                Field<T3> field3)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4> @NotNull Result<Record4<T1,T2,T3,T4>> newResult(Field<T1> field1,
                                                                                                  Field<T2> field2,
                                                                                                  Field<T3> field3,
                                                                                                  Field<T4> field4)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5> @NotNull Result<Record5<T1,T2,T3,T4,T5>> newResult(Field<T1> field1,
                                                                                                                    Field<T2> field2,
                                                                                                                    Field<T3> field3,
                                                                                                                    Field<T4> field4,
                                                                                                                    Field<T5> field5)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6> @NotNull Result<Record6<T1,T2,T3,T4,T5,T6>> newResult(Field<T1> field1,
                                                                                                                                      Field<T2> field2,
                                                                                                                                      Field<T3> field3,
                                                                                                                                      Field<T4> field4,
                                                                                                                                      Field<T5> field5,
                                                                                                                                      Field<T6> field6)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7> @NotNull Result<Record7<T1,T2,T3,T4,T5,T6,T7>> newResult(Field<T1> field1,
                                                                                                                                                        Field<T2> field2,
                                                                                                                                                        Field<T3> field3,
                                                                                                                                                        Field<T4> field4,
                                                                                                                                                        Field<T5> field5,
                                                                                                                                                        Field<T6> field6,
                                                                                                                                                        Field<T7> field7)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8> @NotNull Result<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> newResult(Field<T1> field1,
                                                                                                                                                                          Field<T2> field2,
                                                                                                                                                                          Field<T3> field3,
                                                                                                                                                                          Field<T4> field4,
                                                                                                                                                                          Field<T5> field5,
                                                                                                                                                                          Field<T6> field6,
                                                                                                                                                                          Field<T7> field7,
                                                                                                                                                                          Field<T8> field8)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9> @NotNull Result<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> newResult(Field<T1> field1,
                                                                                                                                                                                            Field<T2> field2,
                                                                                                                                                                                            Field<T3> field3,
                                                                                                                                                                                            Field<T4> field4,
                                                                                                                                                                                            Field<T5> field5,
                                                                                                                                                                                            Field<T6> field6,
                                                                                                                                                                                            Field<T7> field7,
                                                                                                                                                                                            Field<T8> field8,
                                                                                                                                                                                            Field<T9> field9)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> @NotNull Result<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> newResult(Field<T1> field1,
                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                 Field<T10> field10)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> @NotNull Result<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                     Field<T11> field11)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> @NotNull Result<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                         Field<T12> field12)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> @NotNull Result<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                             Field<T13> field13)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> @NotNull Result<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                 Field<T14> field14)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> @NotNull Result<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                     Field<T14> field14,
                                                                                                                                                                                                                                                                                                                     Field<T15> field15)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> @NotNull Result<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                         Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                         Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                         Field<T16> field16)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> @NotNull Result<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                             Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                             Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                             Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                             Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                             Field<T17> field17)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> @NotNull Result<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                 Field<T18> field18)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> @NotNull Result<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                     Field<T19> field19)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> @NotNull Result<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                         Field<T20> field20)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> @NotNull Result<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                             Field<T21> field21)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

newResult

@NotNull
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> @NotNull Result<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> newResult(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                 Field<T22> field22)

Create a new empty Result.

The resulting result is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The new result

fetch

@NotNull
@Support
<R extends Record> @NotNull Result<R> fetch(ResultQuery<R> query)
                                     throws DataAccessException

Execute a ResultQuery in the context of this DSLContext and return results.

Parameters:

query - The query to execute

Returns:

The result. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.fetch()

fetchLazy

@NotNull
@Support
<R extends Record> @NotNull Cursor<R> fetchLazy(ResultQuery<R> query)
                                         throws DataAccessException

Execute a ResultQuery in the context of this DSLContext and return a cursor.

Parameters:

query - The query to execute

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.fetchLazy()

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(ResultQuery<R> query)

Fetch results in a new CompletionStage.

The result is asynchronously completed by a task running in an Executor provided by the Scope.configuration()'s Configuration.executorProvider().

Parameters:

query - The query to execute

Returns:

The completion stage. The completed result will never be null.

See Also:

ResultQuery.fetchAsync()

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                                  ResultQuery<R> query)

Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.

Parameters:

query - The query to execute

Returns:

The completion stage. The completed result will never be null.

See Also:

ResultQuery.fetchAsync()

fetchStream

@NotNull
@Support
<R extends Record> @NotNull Stream<R> fetchStream(ResultQuery<R> query)
                                           throws DataAccessException

Execute a ResultQuery in the context of this DSLContext and return a stream.

Parameters:

query - The query to execute

Returns:

The stream

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.stream()

fetchMany

@NotNull
@Support
<R extends Record> @NotNull Results fetchMany(ResultQuery<R> query)
                                       throws DataAccessException

Execute a ResultQuery in the context of this DSLContext and return a cursor.

Parameters:

query - The query to execute

Returns:

The results. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

ResultQuery.fetchMany()

fetchOne

@Nullable
@Support
<R extends Record> R fetchOne(ResultQuery<R> query)
                       throws DataAccessException,
                              TooManyRowsException

Execute a ResultQuery in the context of this DSLContext and return a record.

Parameters:

query - The query to execute

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

ResultQuery.fetchOne()

fetchSingle

@NotNull
@Support
<R extends Record> R fetchSingle(ResultQuery<R> query)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException

Execute a ResultQuery in the context of this DSLContext and return a record.

Parameters:

query - The query to execute

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned no rows

TooManyRowsException - if the query returned more than one record

See Also:

ResultQuery.fetchSingle()

fetchOptional

@NotNull
@Support
<R extends Record> @NotNull Optional<R> fetchOptional(ResultQuery<R> query)
                                               throws DataAccessException,
                                                      TooManyRowsException

Execute a ResultQuery in the context of this DSLContext and return a record.

Parameters:

query - The query to execute

Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

See Also:

ResultQuery.fetchOptional()

fetchValue

@Nullable
@Support
<T> T fetchValue(Table<? extends Record1<T>> table)
          throws DataAccessException,
                 TooManyRowsException

Fetch a single value from a single column table.

Parameters:

table - The table from which to fetch a value

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue

@Nullable
@Support
<T,R extends Record1<T>> T fetchValue(ResultQuery<R> query)
                                     throws DataAccessException,
                                            TooManyRowsException

Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

query - The query to execute

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue

@Nullable
@Support
<T> T fetchValue(TableField<?,T> field)
          throws DataAccessException,
                 TooManyRowsException

Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

field - The field for which to fetch a single value.

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchValue

@Nullable
@Support
<T> T fetchValue(Field<T> field)
          throws DataAccessException

Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

field - The field for which to fetch a single value.

Returns:

The value or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

fetchOptionalValue

@NotNull
@Support
<T,R extends Record1<T>> @NotNull Optional<T> fetchOptionalValue(ResultQuery<R> query)
                                                                throws DataAccessException,
                                                                       TooManyRowsException,
                                                                       InvalidResultException

Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

query - The query to execute

Returns:

The value.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchOptionalValue

@NotNull
@Support
<T> @NotNull Optional<T> fetchOptionalValue(TableField<?,T> field)
                                     throws DataAccessException,
                                            TooManyRowsException,
                                            InvalidResultException

Execute a ResultQuery in the context of this DSLContext and return a single value.

Parameters:

field - The field for which to fetch a single value.

Returns:

The value.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

InvalidResultException - if the query returned a record with more than one value

fetchValues

@NotNull
@Support
<T> @NotNull List<T> fetchValues(Table<? extends Record1<T>> table)
                          throws DataAccessException

Fetch all values from a single column table.

Parameters:

table - The table from which to fetch values

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchValues

@NotNull
@Support
<T,R extends Record1<T>> @NotNull List<T> fetchValues(ResultQuery<R> query)
                                                     throws DataAccessException

Execute a ResultQuery in the context of this DSLContext and return all values for the only column.

Parameters:

query - The query to execute

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchValues

@NotNull
@Support
<T> @NotNull List<T> fetchValues(TableField<?,T> field)
                          throws DataAccessException

Fetch all values in a given Table's TableField.

Parameters:

field - The field for which to fetch all values.

Returns:

The values. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchByExample

@NotNull
@Support
<R extends TableRecord<R>> @NotNull Result<R> fetchByExample(R example)
                                                      throws DataAccessException

Execute a "Query by Example" (QBE) based on an example record.

Parameters:

example - The example record

Returns:

The resulting records matching the example record.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

DSL.condition(Record)

fetchCount

@Support
int fetchCount(Select<?> query)
        throws DataAccessException

Execute a Select query in the context of this DSLContext and return a COUNT(*) value.

This wraps a pre-existing SELECT query in another one to calculate the COUNT(*) value, without modifying the original SELECT. An example:

 -- Original query:
 SELECT id, title FROM book WHERE title LIKE '%a%'

 -- Wrapped query:
 SELECT count(*) FROM (
   SELECT id, title FROM book WHERE title LIKE '%a%'
 )
 

This is particularly useful for those databases that do not support the COUNT(*) OVER() window function to calculate total results in paged queries.

Parameters:

query - The wrapped query

Returns:

The COUNT(*) result

Throws:

DataAccessException - if something went wrong executing the query

fetchCount

@Support
int fetchCount(Table<?> table)
        throws DataAccessException

Count the number of records in a table.

This executes

SELECT COUNT(*) FROM table

Parameters:

table - The table whose records to count

Returns:

The number of records in the table

Throws:

DataAccessException - if something went wrong executing the query

fetchCount

@Support
int fetchCount(Table<?> table,
               Condition condition)
        throws DataAccessException

Count the number of records in a table that satisfy a condition.

This executes

SELECT COUNT(*) FROM table WHERE condition

Parameters:

table - The table whose records to count

condition - The condition to apply

Returns:

The number of records in the table that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchCount

@Support
int fetchCount(Table<?> table,
               Condition... conditions)
        throws DataAccessException

Count the number of records in a table that satisfy a condition.

This executes

SELECT COUNT(*) FROM table WHERE condition

Convenience API for calling fetchCount(Table, Condition) with DSL.and(Condition...).

Parameters:

table - The table whose records to count

conditions - The conditions to apply

Returns:

The number of records in the table that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchCount

@Support
int fetchCount(Table<?> table,
               Collection<? extends Condition> conditions)
        throws DataAccessException

Count the number of records in a table that satisfy a condition.

This executes

SELECT COUNT(*) FROM table WHERE condition

Convenience API for calling fetchCount(Table, Condition) with DSL.and(Collection).

Parameters:

table - The table whose records to count

conditions - The conditions to apply

Returns:

The number of records in the table that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchExists

@Support
boolean fetchExists(Select<?> query)
             throws DataAccessException

Check if a Select would return any records, if it were executed.

This wraps a pre-existing SELECT query in another one to check for result existence, without modifying the original SELECT. An example:

 -- Original query:
 SELECT id, title FROM book WHERE title LIKE '%a%'

 -- Wrapped query:
 SELECT EXISTS (
   SELECT id, title FROM book WHERE title LIKE '%a%'
 )
 

Parameters:

query - The wrapped query

Returns:

The EXISTS(...) result

Throws:

DataAccessException - if something went wrong executing the query

fetchExists

@Support
boolean fetchExists(Table<?> table)
             throws DataAccessException

Check if a table has any records.

This executes

SELECT EXISTS(SELECT * FROM table)

Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records

Throws:

DataAccessException - if something went wrong executing the query

fetchExists

@Support
boolean fetchExists(Table<?> table,
                    Condition condition)
             throws DataAccessException

Check if a table has any records that satisfy a condition.

This executes

SELECT EXISTS(SELECT * FROM table WHERE condition)

Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchExists

@Support
boolean fetchExists(Table<?> table,
                    Condition... conditions)
             throws DataAccessException

Check if a table has any records that satisfy a condition.

This executes

SELECT EXISTS(SELECT * FROM table WHERE condition)

Convenience API for calling fetchExists(Table, Condition) with DSL.and(Condition...).

Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

fetchExists

@Support
boolean fetchExists(Table<?> table,
                    Collection<? extends Condition> conditions)
             throws DataAccessException

Check if a table has any records that satisfy a condition.

This executes

SELECT EXISTS(SELECT * FROM table WHERE condition)

Convenience API for calling fetchExists(Table, Condition) with DSL.and(Collection).

Parameters:

table - The table whose records to count

Returns:

Whether the table contains any records that satisfy a condition

Throws:

DataAccessException - if something went wrong executing the query

execute

@Support
int execute(Query query)
     throws DataAccessException

Execute a Query in the context of this DSLContext.

Parameters:

query - The query to execute

Returns:

The number of affected rows

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Query.execute()

fetch

@NotNull
@Support
<R extends Record> @NotNull Result<R> fetch(Table<R> table)
                                     throws DataAccessException

Execute and return all records for

SELECT table.col1, table.col2 FROM table

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch

@NotNull
@Support
<R extends Record> @NotNull Result<R> fetch(Table<R> table,
                                            Condition condition)
                                     throws DataAccessException

Execute and return all records for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch

@NotNull
@Support
<R extends Record> @NotNull Result<R> fetch(Table<R> table,
                                            Condition... conditions)
                                     throws DataAccessException

Execute and return all records for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetch(Table, Condition) with DSL.and(Condition...).

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetch

@NotNull
@Support
<R extends Record> @NotNull Result<R> fetch(Table<R> table,
                                            Collection<? extends Condition> conditions)
                                     throws DataAccessException

Execute and return all records for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetch(Table, Condition) with DSL.and(Collection).

Returns:

The results from the executed query. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchOne

@Nullable
@Support
<R extends Record> R fetchOne(Table<R> table)
                       throws DataAccessException,
                              TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne

@Nullable
@Support
<R extends Record> R fetchOne(Table<R> table,
                              Condition condition)
                       throws DataAccessException,
                              TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne

@Nullable
@Support
<R extends Record> R fetchOne(Table<R> table,
                              Condition... conditions)
                       throws DataAccessException,
                              TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchOne(Table, Condition) with DSL.and(Condition...).

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOne

@Nullable
@Support
<R extends Record> R fetchOne(Table<R> table,
                              Collection<? extends Condition> conditions)
                       throws DataAccessException,
                              TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchOne(Table, Condition) with DSL.and(Collection).

Returns:

The record or null, if no record was found.

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
<R extends Record> R fetchSingle(Table<R> table)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException

Execute and return exactly one record for

SELECT table.col1, table.col2 FROM table

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
<R extends Record> R fetchSingle(Table<R> table,
                                 Condition condition)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException

Execute and return exactly one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
<R extends Record> R fetchSingle(Table<R> table,
                                 Condition... conditions)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException

Execute and return exactly one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(Table, Condition) with DSL.and(Condition...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
<R extends Record> R fetchSingle(Table<R> table,
                                 Collection<? extends Condition> conditions)
                          throws DataAccessException,
                                 NoDataFoundException,
                                 TooManyRowsException

Execute and return exactly one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(Table, Condition) with DSL.and(Collection).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

NoDataFoundException - if the query returned now rows

TooManyRowsException - if the query returned more than one record

fetchSingle

@NotNull
@Support
@NotNull Record fetchSingle(SelectField<?>... fields)
                     throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
@NotNull Record fetchSingle(Collection<? extends SelectField<?>> fields)
                     throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1> @NotNull Record1<T1> fetchSingle(SelectField<T1> field1)
                               throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2> @NotNull Record2<T1,T2> fetchSingle(SelectField<T1> field1,
                                                        SelectField<T2> field2)
                                                 throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3> @NotNull Record3<T1,T2,T3> fetchSingle(SelectField<T1> field1,
                                                                          SelectField<T2> field2,
                                                                          SelectField<T3> field3)
                                                                   throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4> @NotNull Record4<T1,T2,T3,T4> fetchSingle(SelectField<T1> field1,
                                                                                            SelectField<T2> field2,
                                                                                            SelectField<T3> field3,
                                                                                            SelectField<T4> field4)
                                                                                     throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5> @NotNull Record5<T1,T2,T3,T4,T5> fetchSingle(SelectField<T1> field1,
                                                                                                              SelectField<T2> field2,
                                                                                                              SelectField<T3> field3,
                                                                                                              SelectField<T4> field4,
                                                                                                              SelectField<T5> field5)
                                                                                                       throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6> @NotNull Record6<T1,T2,T3,T4,T5,T6> fetchSingle(SelectField<T1> field1,
                                                                                                                                SelectField<T2> field2,
                                                                                                                                SelectField<T3> field3,
                                                                                                                                SelectField<T4> field4,
                                                                                                                                SelectField<T5> field5,
                                                                                                                                SelectField<T6> field6)
                                                                                                                         throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7> @NotNull Record7<T1,T2,T3,T4,T5,T6,T7> fetchSingle(SelectField<T1> field1,
                                                                                                                                                  SelectField<T2> field2,
                                                                                                                                                  SelectField<T3> field3,
                                                                                                                                                  SelectField<T4> field4,
                                                                                                                                                  SelectField<T5> field5,
                                                                                                                                                  SelectField<T6> field6,
                                                                                                                                                  SelectField<T7> field7)
                                                                                                                                           throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8> @NotNull Record8<T1,T2,T3,T4,T5,T6,T7,T8> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                    SelectField<T2> field2,
                                                                                                                                                                    SelectField<T3> field3,
                                                                                                                                                                    SelectField<T4> field4,
                                                                                                                                                                    SelectField<T5> field5,
                                                                                                                                                                    SelectField<T6> field6,
                                                                                                                                                                    SelectField<T7> field7,
                                                                                                                                                                    SelectField<T8> field8)
                                                                                                                                                             throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9> @NotNull Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                      SelectField<T2> field2,
                                                                                                                                                                                      SelectField<T3> field3,
                                                                                                                                                                                      SelectField<T4> field4,
                                                                                                                                                                                      SelectField<T5> field5,
                                                                                                                                                                                      SelectField<T6> field6,
                                                                                                                                                                                      SelectField<T7> field7,
                                                                                                                                                                                      SelectField<T8> field8,
                                                                                                                                                                                      SelectField<T9> field9)
                                                                                                                                                                               throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> @NotNull Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                           SelectField<T2> field2,
                                                                                                                                                                                                           SelectField<T3> field3,
                                                                                                                                                                                                           SelectField<T4> field4,
                                                                                                                                                                                                           SelectField<T5> field5,
                                                                                                                                                                                                           SelectField<T6> field6,
                                                                                                                                                                                                           SelectField<T7> field7,
                                                                                                                                                                                                           SelectField<T8> field8,
                                                                                                                                                                                                           SelectField<T9> field9,
                                                                                                                                                                                                           SelectField<T10> field10)
                                                                                                                                                                                                    throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> @NotNull Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                               SelectField<T2> field2,
                                                                                                                                                                                                                               SelectField<T3> field3,
                                                                                                                                                                                                                               SelectField<T4> field4,
                                                                                                                                                                                                                               SelectField<T5> field5,
                                                                                                                                                                                                                               SelectField<T6> field6,
                                                                                                                                                                                                                               SelectField<T7> field7,
                                                                                                                                                                                                                               SelectField<T8> field8,
                                                                                                                                                                                                                               SelectField<T9> field9,
                                                                                                                                                                                                                               SelectField<T10> field10,
                                                                                                                                                                                                                               SelectField<T11> field11)
                                                                                                                                                                                                                        throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> @NotNull Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                   SelectField<T2> field2,
                                                                                                                                                                                                                                                   SelectField<T3> field3,
                                                                                                                                                                                                                                                   SelectField<T4> field4,
                                                                                                                                                                                                                                                   SelectField<T5> field5,
                                                                                                                                                                                                                                                   SelectField<T6> field6,
                                                                                                                                                                                                                                                   SelectField<T7> field7,
                                                                                                                                                                                                                                                   SelectField<T8> field8,
                                                                                                                                                                                                                                                   SelectField<T9> field9,
                                                                                                                                                                                                                                                   SelectField<T10> field10,
                                                                                                                                                                                                                                                   SelectField<T11> field11,
                                                                                                                                                                                                                                                   SelectField<T12> field12)
                                                                                                                                                                                                                                            throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> @NotNull Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                       SelectField<T2> field2,
                                                                                                                                                                                                                                                                       SelectField<T3> field3,
                                                                                                                                                                                                                                                                       SelectField<T4> field4,
                                                                                                                                                                                                                                                                       SelectField<T5> field5,
                                                                                                                                                                                                                                                                       SelectField<T6> field6,
                                                                                                                                                                                                                                                                       SelectField<T7> field7,
                                                                                                                                                                                                                                                                       SelectField<T8> field8,
                                                                                                                                                                                                                                                                       SelectField<T9> field9,
                                                                                                                                                                                                                                                                       SelectField<T10> field10,
                                                                                                                                                                                                                                                                       SelectField<T11> field11,
                                                                                                                                                                                                                                                                       SelectField<T12> field12,
                                                                                                                                                                                                                                                                       SelectField<T13> field13)
                                                                                                                                                                                                                                                                throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> @NotNull Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                           SelectField<T2> field2,
                                                                                                                                                                                                                                                                                           SelectField<T3> field3,
                                                                                                                                                                                                                                                                                           SelectField<T4> field4,
                                                                                                                                                                                                                                                                                           SelectField<T5> field5,
                                                                                                                                                                                                                                                                                           SelectField<T6> field6,
                                                                                                                                                                                                                                                                                           SelectField<T7> field7,
                                                                                                                                                                                                                                                                                           SelectField<T8> field8,
                                                                                                                                                                                                                                                                                           SelectField<T9> field9,
                                                                                                                                                                                                                                                                                           SelectField<T10> field10,
                                                                                                                                                                                                                                                                                           SelectField<T11> field11,
                                                                                                                                                                                                                                                                                           SelectField<T12> field12,
                                                                                                                                                                                                                                                                                           SelectField<T13> field13,
                                                                                                                                                                                                                                                                                           SelectField<T14> field14)
                                                                                                                                                                                                                                                                                    throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> @NotNull Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                               SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                               SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                               SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                               SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                               SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                               SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                               SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                               SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                               SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                               SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                               SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                               SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                               SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                               SelectField<T15> field15)
                                                                                                                                                                                                                                                                                                        throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> @NotNull Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                   SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                   SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                   SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                   SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                   SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                   SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                   SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                   SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                   SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                   SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                   SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                   SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                   SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                   SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                   SelectField<T16> field16)
                                                                                                                                                                                                                                                                                                                            throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> @NotNull Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                       SelectField<T17> field17)
                                                                                                                                                                                                                                                                                                                                                throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> @NotNull Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                           SelectField<T18> field18)
                                                                                                                                                                                                                                                                                                                                                                    throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> @NotNull Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                               SelectField<T19> field19)
                                                                                                                                                                                                                                                                                                                                                                                        throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> @NotNull Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                   SelectField<T20> field20)
                                                                                                                                                                                                                                                                                                                                                                                                            throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> @NotNull Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                       SelectField<T21> field21)
                                                                                                                                                                                                                                                                                                                                                                                                                                throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchSingle

@NotNull
@Support
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> @NotNull Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> fetchSingle(SelectField<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                           SelectField<T22> field22)
                                                                                                                                                                                                                                                                                                                                                                                                                                                    throws DataAccessException

Execute and return exactly one record for

SELECT F1, F2, ..., FN

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchSingle(ResultQuery) with DSL.select(SelectFieldOrAsterisk...).

Returns:

The record. This is never null.

Throws:

DataAccessException - if something went wrong executing the query

fetchOptional

@NotNull
@Support
<R extends Record> @NotNull Optional<R> fetchOptional(Table<R> table)
                                               throws DataAccessException,
                                                      TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
<R extends Record> @NotNull Optional<R> fetchOptional(Table<R> table,
                                                      Condition condition)
                                               throws DataAccessException,
                                                      TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
<R extends Record> @NotNull Optional<R> fetchOptional(Table<R> table,
                                                      Condition... conditions)
                                               throws DataAccessException,
                                                      TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchOptional(Table, Condition) with DSL.and(Condition...).

Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchOptional

@NotNull
@Support
<R extends Record> @NotNull Optional<R> fetchOptional(Table<R> table,
                                                      Collection<? extends Condition> conditions)
                                               throws DataAccessException,
                                                      TooManyRowsException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchOptional(Table, Condition) with DSL.and(Collection).

Returns:

The record

Throws:

DataAccessException - if something went wrong executing the query

TooManyRowsException - if the query returned more than one record

fetchAny

@Nullable
@Support
<R extends Record> R fetchAny(Table<R> table)
                       throws DataAccessException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table LIMIT 1

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchAny

@Nullable
@Support
<R extends Record> R fetchAny(Table<R> table,
                              Condition condition)
                       throws DataAccessException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition LIMIT 1

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchAny

@Nullable
@Support
<R extends Record> R fetchAny(Table<R> table,
                              Condition... conditions)
                       throws DataAccessException

Execute and return zero or on e record for

SELECT table.col1, table.col2 FROM table WHERE condition LIMIT 1

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAny(Table, Condition) with DSL.and(Condition...).

Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchAny

@Nullable
@Support
<R extends Record> R fetchAny(Table<R> table,
                              Collection<? extends Condition> conditions)
                       throws DataAccessException

Execute and return zero or one record for

SELECT table.col1, table.col2 FROM table WHERE condition LIMIT 1

.

The resulting record is attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAny(Table, Condition) with DSL.and(Collection).

Returns:

The record or null if no record was returned

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
<R extends Record> @NotNull Cursor<R> fetchLazy(Table<R> table)
                                         throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
<R extends Record> @NotNull Cursor<R> fetchLazy(Table<R> table,
                                                Condition condition)
                                         throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
<R extends Record> @NotNull Cursor<R> fetchLazy(Table<R> table,
                                                Condition... conditions)
                                         throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchLazy(Table, Condition) with DSL.and(Condition...).

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

@NotNull
@Support
<R extends Record> @NotNull Cursor<R> fetchLazy(Table<R> table,
                                                Collection<? extends Condition> conditions)
                                         throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchLazy(Table, Condition) with DSL.and(Collection).

Returns:

The cursor. This will never be null.

Throws:

DataAccessException - if something went wrong executing the query

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Table<R> table)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Table<R> table,
                                                                  Condition condition)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Table<R> table,
                                                                  Condition... condition)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAsync(Table, Condition) with DSL.and(Condition...).

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Table<R> table,
                                                                  Collection<? extends Condition> condition)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAsync(Table, Condition) with DSL.and(Collection).

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                                  Table<R> table)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                                  Table<R> table,
                                                                  Condition condition)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                                  Table<R> table,
                                                                  Condition... conditions)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAsync(Executor, Table, Condition) with DSL.and(Condition...).

Returns:

The completion stage. The completed result will never be null.

fetchAsync

@NotNull
@Support
<R extends Record> @NotNull CompletionStage<Result<R>> fetchAsync(Executor executor,
                                                                  Table<R> table,
                                                                  Collection<? extends Condition> conditions)

Execute and return all records asynchronously for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchAsync(Executor, Table, Condition) with DSL.and(Collection).

Returns:

The completion stage. The completed result will never be null.

fetchStream

@NotNull
@Support
<R extends Record> @NotNull Stream<R> fetchStream(Table<R> table)
                                           throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@NotNull
@Support
<R extends Record> @NotNull Stream<R> fetchStream(Table<R> table,
                                                  Condition condition)
                                           throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@NotNull
@Support
<R extends Record> @NotNull Stream<R> fetchStream(Table<R> table,
                                                  Condition... conditions)
                                           throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchStream(Table, Condition) with DSL.and(Condition...).

Throws:

DataAccessException - if something went wrong executing the query

fetchStream

@NotNull
@Support
<R extends Record> @NotNull Stream<R> fetchStream(Table<R> table,
                                                  Collection<? extends Condition> conditions)
                                           throws DataAccessException

Execute and return all records lazily for

SELECT table.col1, table.col2 FROM table WHERE condition

.

The result and its contained records are attached to this Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Convenience API for calling fetchStream(Table, Condition) with DSL.and(Collection).

Throws:

DataAccessException - if something went wrong executing the query

executeInsert

@Support
int executeInsert(TableRecord<?> record)
           throws DataAccessException

Insert one record.

This executes something like the following statement:

INSERT INTO [table] ... VALUES [record] 

Unlike UpdatableRecord.store(), this does not change any of the argument record's internal "changed" flags, such that a subsequent call to UpdatableRecord.store() might lead to another INSERT statement being executed.

Returns:

The number of inserted records

Throws:

DataAccessException - if something went wrong executing the query

executeUpdate

@Support
int executeUpdate(UpdatableRecord<?> record)
           throws DataAccessException

Update a table.

UPDATE [table] SET [modified values in record] WHERE [record is supplied record] 

Returns:

The number of updated records

Throws:

DataAccessException - if something went wrong executing the query

executeUpdate

@Support
int executeUpdate(TableRecord<?> record,
                  Condition condition)
           throws DataAccessException

Update a table.

UPDATE [table] SET [modified values in record] WHERE [condition]

Returns:

The number of updated records

Throws:

DataAccessException - if something went wrong executing the query

executeDelete

@Support
int executeDelete(UpdatableRecord<?> record)
           throws DataAccessException

Delete a record from a table.

DELETE FROM [table] WHERE [record is supplied record]

Returns:

The number of deleted records

Throws:

DataAccessException - if something went wrong executing the query

executeDelete

@Support
int executeDelete(TableRecord<?> record,
                  Condition condition)
           throws DataAccessException

Delete a record from a table.

DELETE FROM [table] WHERE [condition]

Returns:

The number of deleted records

Throws:

DataAccessException - if something went wrong executing the query