public interface DSLContext
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 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.
DSL,
Configuration| Modifier and Type | Method and Description |
|---|---|
void |
attach(Attachable... attachables)
Attach this
DSLContext's underlying configuration()
to some attachables. |
void |
attach(Collection<? extends Attachable> attachables)
Attach this
DSLContext's underlying configuration()
to some attachables. |
Batch |
batch(Collection<? extends Query> queries)
Execute a set of queries in batch mode (without bind values).
|
Batch |
batch(Query... queries)
Execute a set of queries in batch mode (without bind values).
|
BatchBindStep |
batch(Query query)
Execute a set of queries in batch mode (with bind values).
|
Batch |
batch(Query query,
Object[]... bindings)
Execute a set of queries in batch mode (with bind values).
|
Batch |
batch(String... queries)
Execute a set of queries in batch mode (without bind values).
|
BatchBindStep |
batch(String sql)
Execute a set of queries in batch mode (with bind values).
|
Batch |
batch(String sql,
Object[]... bindings)
Execute a set of queries in batch mode (with bind values).
|
Batch |
batchDelete(Collection<? extends UpdatableRecord<?>> records)
Execute a set of
DELETE in batch mode (with bind values). |
Batch |
batchDelete(UpdatableRecord<?>... records)
Execute a set of
DELETE queries in batch mode (with bind
values). |
Batch |
batchInsert(Collection<? extends UpdatableRecord<?>> records)
Execute a set of
INSERT queries in batch mode (with bind
values). |
Batch |
batchInsert(UpdatableRecord<?>... records)
Execute a set of
INSERT queries in batch mode (with bind
values). |
Batch |
batchStore(Collection<? extends UpdatableRecord<?>> records)
Execute a set of
INSERT and UPDATE queries in
batch mode (with bind values). |
Batch |
batchStore(UpdatableRecord<?>... records)
Execute a set of
INSERT and UPDATE queries in
batch mode (with bind values). |
Batch |
batchUpdate(Collection<? extends UpdatableRecord<?>> records)
Execute a set of
UPDATE queries in batch mode (with bind
values). |
Batch |
batchUpdate(UpdatableRecord<?>... records)
Execute a set of
UPDATE queries in batch mode (with bind
values). |
int |
bind(QueryPart part,
PreparedStatement stmt)
Deprecated.
- [#2662] - 3.2.0 - Do not reuse this method. It will be
removed with jOOQ 4.0
|
BindContext |
bindContext(PreparedStatement stmt)
Get a new
BindContext for the context of this executor. |
Configuration |
configuration()
The
Configuration referenced from this
DSLContext. |
<T extends Number> |
currval(Sequence<T> sequence)
Convenience method to fetch the CURRVAL for a sequence directly from this
DSLContext's underlying JDBC Connection |
<R extends Record> |
delete(Table<R> table)
Create a new DSL delete statement.
|
<R extends Record> |
deleteQuery(Table<R> table)
Create a new
DeleteQuery |
int |
execute(Query query)
Execute a
Query in the context of this executor. |
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.
|
<R extends UpdatableRecord<R>> |
executeDelete(R record)
Delete a record from a table.
|
<R extends TableRecord<R>,T> |
executeDelete(R record,
Condition condition)
Delete a record from a table.
|
<R extends TableRecord<R>> |
executeInsert(R record)
Insert one record.
|
<R extends UpdatableRecord<R>> |
executeUpdate(R record)
Update a table.
|
<R extends TableRecord<R>,T> |
executeUpdate(R record,
Condition condition)
Update a table.
|
List<Object> |
extractBindValues(QueryPart part)
Retrieve the bind values that will be bound by a given
QueryPart. |
Param<?> |
extractParam(QueryPart part,
String name)
Get a named parameter from a
QueryPart, provided its name. |
Map<String,Param<?>> |
extractParams(QueryPart part)
Get a
Map of named parameters. |
<R extends Record> |
fetch(ResultQuery<R> query)
Execute a
ResultQuery in the context of this executor and return
results. |
Result<Record> |
fetch(ResultSet rs)
|
Result<Record> |
fetch(ResultSet rs,
Class<?>... types)
|
Result<Record> |
fetch(ResultSet rs,
DataType<?>... types)
|
Result<Record> |
fetch(ResultSet rs,
Field<?>... fields)
|
Result<Record> |
fetch(String sql)
Execute a new query holding plain SQL.
|
Result<Record> |
fetch(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Result<Record> |
fetch(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends Record> |
fetch(Table<R> table)
Execute and return all records for
SELECT * FROM [table]. |
<R extends Record> |
fetch(Table<R> table,
Condition condition)
Execute and return all records for
SELECT * FROM [table] WHERE [condition] . |
<R extends Record> |
fetchAny(Table<R> table)
Execute and return zero or one record for
SELECT * FROM [table] LIMIT 1. |
<R extends Record> |
fetchAny(Table<R> table,
Condition condition)
Execute and return zero or one record for
SELECT * FROM [table] WHERE [condition] LIMIT 1. |
int |
fetchCount(Select<?> query)
Execute a
Select query in the context of this executor and return
a COUNT(*) value. |
Result<Record> |
fetchFromCSV(String string)
Fetch all data from a CSV string.
|
Result<Record> |
fetchFromCSV(String string,
char delimiter)
Fetch all data from a CSV string.
|
Result<Record> |
fetchFromStringData(List<String[]> data)
Fetch all data from a list of strings.
|
Result<Record> |
fetchFromStringData(String[]... data)
Fetch all data from a list of strings.
|
Result<Record> |
fetchFromTXT(String string)
Fetch all data from a formatted string.
|
Result<Record> |
fetchFromTXT(String string,
String nullLiteral)
Fetch all data from a formatted string.
|
<R extends Record> |
fetchLazy(ResultQuery<R> query)
Execute a
ResultQuery in the context of this executor and return
a cursor. |
Cursor<Record> |
fetchLazy(ResultSet rs)
|
Cursor<Record> |
fetchLazy(ResultSet rs,
Class<?>... types)
|
Cursor<Record> |
fetchLazy(ResultSet rs,
DataType<?>... types)
|
Cursor<Record> |
fetchLazy(ResultSet rs,
Field<?>... fields)
|
Cursor<Record> |
fetchLazy(String sql)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
fetchLazy(String sql,
Object... bindings)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
fetchLazy(String sql,
QueryPart... parts)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
<R extends Record> |
fetchLazy(Table<R> table)
Execute and return all records lazily for
SELECT * FROM [table]. |
<R extends Record> |
fetchLazy(Table<R> table,
Condition condition)
Execute and return all records lazily for
SELECT * FROM [table] WHERE [condition] . |
<R extends Record> |
fetchMany(ResultQuery<R> query)
Execute a
ResultQuery in the context of this executor and return
a cursor. |
List<Result<Record>> |
fetchMany(String sql)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
List<Result<Record>> |
fetchMany(String sql,
Object... bindings)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
List<Result<Record>> |
fetchMany(String sql,
QueryPart... parts)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
<R extends Record> |
fetchOne(ResultQuery<R> query)
Execute a
ResultQuery in the context of this executor and return
a record. |
Record |
fetchOne(ResultSet rs)
|
Record |
fetchOne(ResultSet rs,
Class<?>... types)
|
Record |
fetchOne(ResultSet rs,
DataType<?>... types)
|
Record |
fetchOne(ResultSet rs,
Field<?>... fields)
|
Record |
fetchOne(String sql)
Execute a new query holding plain SQL.
|
Record |
fetchOne(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Record |
fetchOne(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends Record> |
fetchOne(Table<R> table)
Execute and return zero or one record for
SELECT * FROM [table]. |
<R extends Record> |
fetchOne(Table<R> table,
Condition condition)
Execute and return zero or one record for
SELECT * FROM [table] WHERE [condition] . |
<R extends Record> |
insertInto(Table<R> into)
Create a new DSL insert statement.
|
<R extends Record> |
insertInto(Table<R> into,
Collection<? extends Field<?>> fields)
Create a new DSL insert statement.
|
<R extends Record> |
insertInto(Table<R> into,
Field<?>... fields)
Create a new DSL insert statement.
|
<R extends Record,T1> |
insertInto(Table<R> into,
Field<T1> field1)
Create a new DSL insert statement.
|
<R extends Record,T1,T2> |
insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2)
Create a new DSL insert statement.
|
<R extends Record,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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
insertInto(Table<R> into,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22)
Create a new DSL insert statement.
|
<R extends Record> |
insertQuery(Table<R> into)
Create a new
InsertQuery |
BigInteger |
lastID()
Retrieve the last inserted ID.
|
<R extends TableRecord<R>> |
loadInto(Table<R> table)
Create a new
Loader object to load data from a CSV or XML
source. |
Schema |
map(Schema schema)
Map a schema to another one.
|
<R extends Record> |
map(Table<R> table)
Map a table to another one.
|
<R extends Record> |
mergeInto(Table<R> table)
Create a new DSL SQL standard MERGE statement.
|
<R extends Record> |
mergeInto(Table<R> table,
Collection<? extends Field<?>> fields)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record> |
mergeInto(Table<R> table,
Field<?>... fields)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1> |
mergeInto(Table<R> table,
Field<T1> field1)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20)
Create a new DSL merge statement (H2-specific syntax).
|
<R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21)
Create a new DSL merge statement (H2-specific syntax).
|
<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> |
mergeInto(Table<R> table,
Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22)
Create a new DSL merge statement (H2-specific syntax).
|
Meta |
meta()
Access the database meta data.
|
Record |
newRecord(Field<?>... fields)
Create a new empty
Record. |
<T1> Record1<T1> |
newRecord(Field<T1> field1)
Create a new empty
Record. |
<T1,T2> Record2<T1,T2> |
newRecord(Field<T1> field1,
Field<T2> field2)
Create a new empty
Record. |
<T1,T2,T3> Record3<T1,T2,T3> |
newRecord(Field<T1> field1,
Field<T2> field2,
Field<T3> field3)
Create a new empty
Record. |
<T1,T2,T3,T4> |
newRecord(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4)
Create a new empty
Record. |
<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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
newRecord(Table<R> table)
Create a new
Record that can be inserted into the corresponding
table. |
<R extends Record> |
newRecord(Table<R> table,
Object source)
Create a new pre-filled
Record that can be inserted into the
corresponding table. |
<R extends UDTRecord<R>> |
newRecord(UDT<R> type)
Create a new
UDTRecord. |
<R extends Record> |
newResult(Table<R> table)
Create a new empty
Result. |
<T extends Number> |
nextval(Sequence<T> sequence)
Convenience method to fetch the NEXTVAL for a sequence directly from this
DSLContext's underlying JDBC Connection |
Query |
query(String sql)
Create a new query holding plain SQL.
|
Query |
query(String sql,
Object... bindings)
Create a new query holding plain SQL.
|
Query |
query(String sql,
QueryPart... parts)
Create a new query holding plain SQL.
|
String |
render(QueryPart part)
Render a QueryPart in the context of this executor.
|
RenderContext |
renderContext()
Get a new
RenderContext for the context of this executor. |
String |
renderInlined(QueryPart part)
Render a QueryPart in the context of this executor, inlining all bind
variables.
|
String |
renderNamedParams(QueryPart part)
Render a QueryPart in the context of this executor, rendering bind
variables as named parameters.
|
ResultQuery<Record> |
resultQuery(String sql)
Create a new query holding plain SQL.
|
ResultQuery<Record> |
resultQuery(String sql,
Object... bindings)
Create a new query holding plain SQL.
|
ResultQuery<Record> |
resultQuery(String sql,
QueryPart... parts)
Create a new query holding plain SQL.
|
SelectSelectStep<Record> |
select(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
SelectSelectStep<Record> |
select(Field<?>... fields)
Create a new DSL select statement.
|
<T1> SelectSelectStep<Record1<T1>> |
select(Field<T1> field1)
Create a new DSL select statement.
|
<T1,T2> SelectSelectStep<Record2<T1,T2>> |
select(Field<T1> field1,
Field<T2> field2)
Create a new DSL select statement.
|
<T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3)
Create a new DSL select statement.
|
<T1,T2,T3,T4> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> |
select(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22)
Create a new DSL select statement.
|
SelectSelectStep<Record1<Integer>> |
selectCount()
Create a new DSL select statement for
COUNT(*). |
SelectSelectStep<Record> |
selectDistinct(Collection<? extends Field<?>> fields)
Create a new DSL select statement.
|
SelectSelectStep<Record> |
selectDistinct(Field<?>... fields)
Create a new DSL select statement.
|
<T1> SelectSelectStep<Record1<T1>> |
selectDistinct(Field<T1> field1)
Create a new DSL select statement.
|
<T1,T2> SelectSelectStep<Record2<T1,T2>> |
selectDistinct(Field<T1> field1,
Field<T2> field2)
Create a new DSL select statement.
|
<T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3)
Create a new DSL select statement.
|
<T1,T2,T3,T4> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21)
Create a new DSL select statement.
|
<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> |
selectDistinct(Field<T1> field1,
Field<T2> field2,
Field<T3> field3,
Field<T4> field4,
Field<T5> field5,
Field<T6> field6,
Field<T7> field7,
Field<T8> field8,
Field<T9> field9,
Field<T10> field10,
Field<T11> field11,
Field<T12> field12,
Field<T13> field13,
Field<T14> field14,
Field<T15> field15,
Field<T16> field16,
Field<T17> field17,
Field<T18> field18,
Field<T19> field19,
Field<T20> field20,
Field<T21> field21,
Field<T22> field22)
Create a new DSL select statement.
|
<R extends Record> |
selectFrom(Table<R> table)
Create a new DSL select statement.
|
SelectSelectStep<Record1<Integer>> |
selectOne()
Create a new DSL select statement for a constant
1 literal. |
SelectQuery<Record> |
selectQuery()
Create a new
SelectQuery |
<R extends Record> |
selectQuery(TableLike<R> table)
Create a new
SelectQuery |
SelectSelectStep<Record1<Integer>> |
selectZero()
Create a new DSL select statement for a constant
0 literal. |
<R extends Record> |
truncate(Table<R> table)
Create a new DSL truncate statement.
|
<R extends Record> |
update(Table<R> table)
Create a new DSL update statement.
|
<R extends Record> |
updateQuery(Table<R> table)
Create a new
UpdateQuery |
Configuration configuration()
Configuration referenced from this
DSLContext.Schema map(Schema schema)
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.
schema - A schema<R extends Record> Table<R> map(Table<R> table)
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.
table - A tableMeta meta()
This method returns a wrapper type that gives access to your JDBC connection's database meta data.
RenderContext renderContext()
RenderContext for the context of this executor.
This will return an initialised render context as such:
RenderContext.castMode() == DEFAULTContext.declareFields() == falseContext.declareTables() == falseRenderContext.format() == falseRenderContext.paramType() == ParamType.INDEXEDRenderContext.qualify() == trueContext.subquery() == falseString render(QueryPart part)
This is the same as calling renderContext().render(part)
part - The QueryPart to be renderedString renderNamedParams(QueryPart part)
This is the same as calling
renderContext().namedParams(true).render(part)
part - The QueryPart to be renderedString renderInlined(QueryPart part)
This is the same as calling
renderContext().inline(true).render(part)
part - The QueryPart to be renderedList<Object> extractBindValues(QueryPart part)
QueryPart.
The returned List is immutable. To modify bind values, use
extractParams(QueryPart) instead.
Map<String,Param<?>> extractParams(QueryPart part)
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.
Param,
DSL.param(String, Object)Param<?> extractParam(QueryPart part, String name)
QueryPart, provided its name.
Bind values created with DSL.val(Object) will have their bind
index as name.
Param,
DSL.param(String, Object)BindContext bindContext(PreparedStatement stmt)
BindContext for the context of this executor.
This will return an initialised bind context as such:
Context.declareFields() == falseContext.declareTables() == falseBindContext for JOOQ INTERNAL USE only. Avoid referencing it directly
@Deprecated int bind(QueryPart part, PreparedStatement stmt)
void attach(Attachable... attachables)
DSLContext's underlying configuration()
to some attachables.void attach(Collection<? extends Attachable> attachables)
DSLContext's underlying configuration()
to some attachables.@Support <R extends TableRecord<R>> LoaderOptionsStep<R> loadInto(Table<R> table)
Loader object to load data from a CSV or XML
source.@Support Query query(String 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!
sql - The SQL@Support Query query(String sql, Object... bindings)
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!
sql - The SQLbindings - The bindings@Support Query query(String sql, QueryPart... parts)
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locations@Support Result<Record> fetch(String sql) throws DataAccessException
Example (Postgres):
String sql = "FETCH ALL IN \"
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!
sql - The SQLnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the query@Support Result<Record> fetch(String sql, Object... bindings) throws DataAccessException
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
String sql = "FETCH ALL IN \"
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!
sql - The SQLbindings - The bindingsnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the query@Support Result<Record> fetch(String sql, QueryPart... parts) throws DataAccessException
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsDataAccessException - if something went wrong executing the query@Support Cursor<Record> fetchLazy(String sql) throws DataAccessException
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 \"
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!
sql - The SQLnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the query@Support Cursor<Record> fetchLazy(String sql, Object... bindings) throws DataAccessException
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 \"
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!
sql - The SQLbindings - The bindingsnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the query@Support Cursor<Record> fetchLazy(String sql, QueryPart... parts) throws DataAccessException
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsDataAccessException - if something went wrong executing the query@Support List<Result<Record>> fetchMany(String sql) throws DataAccessException
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!
sql - The SQLnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the query@Support List<Result<Record>> fetchMany(String sql, Object... bindings) throws DataAccessException
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!
sql - The SQLbindings - The bindingsnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the query@Support List<Result<Record>> fetchMany(String sql, QueryPart... parts) throws DataAccessException
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsDataAccessException - if something went wrong executing the query@Support Record fetchOne(String sql) throws DataAccessException, InvalidResultException
Example (Postgres):
String sql = "FETCH ALL IN \"
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!
sql - The SQLnull, even if the database returns no
ResultSetDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support Record fetchOne(String sql, Object... bindings) throws DataAccessException, InvalidResultException
There must be as many bind variables contained in the SQL, as passed in the bindings parameter
Example (Postgres):
String sql = "FETCH ALL IN \"
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!
sql - The SQLbindings - The bindingsnull if the database returned no recordsDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support Record fetchOne(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsnull if the database returned no recordsDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support int execute(String sql) throws DataAccessException
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!
sql - The SQLDataAccessException - if something went wrong executing the query@Support int execute(String sql, Object... bindings) throws DataAccessException
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!
sql - The SQLbindings - The bindingsDataAccessException - if something went wrong executing the query@Support int execute(String sql, QueryPart... parts) throws DataAccessException
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locationsDataAccessException - if something went wrong executing the query@Support ResultQuery<Record> resultQuery(String sql)
There must not be any binding 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 \"
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!
sql - The SQL@Support ResultQuery<Record> resultQuery(String sql, Object... bindings)
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 \"
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!
sql - The SQLbindings - The bindings@Support ResultQuery<Record> resultQuery(String sql, QueryPart... parts)
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 on an Oracle database with RenderNameStyle.QUOTED:
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
sql - The SQL clause, containing {numbered placeholders} where query
parts can be injectedparts - The QueryPart objects that are rendered at the
{numbered placeholder} locations@Support Result<Record> fetch(ResultSet rs) throws DataAccessException
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.
rs - The JDBC ResultSet to fetch data fromDataAccessException - if something went wrong executing the query@Support Result<Record> fetch(ResultSet rs, Field<?>... fields) throws DataAccessException
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
rs - The JDBC ResultSet to fetch data fromfields - The fields to use in the desired outputDataAccessException - if something went wrong executing the query@Support Result<Record> fetch(ResultSet rs, DataType<?>... types) throws DataAccessException
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
rs - The JDBC ResultSet to fetch data fromtypes - The data types to use in the desired outputDataAccessException - if something went wrong executing the query@Support Result<Record> fetch(ResultSet rs, Class<?>... types) throws DataAccessException
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
rs - The JDBC ResultSet to fetch data fromtypes - The data types to use in the desired outputDataAccessException - if something went wrong executing the query@Support Record fetchOne(ResultSet rs) throws DataAccessException, InvalidResultException
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.
rs - The JDBC ResultSet to fetch data fromDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support Record fetchOne(ResultSet rs, Field<?>... fields) throws DataAccessException, InvalidResultException
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
rs - The JDBC ResultSet to fetch data fromfields - The fields to use in the desired outputDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support Record fetchOne(ResultSet rs, DataType<?>... types) throws DataAccessException, InvalidResultException
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
rs - The JDBC ResultSet to fetch data fromtypes - The data types to use in the desired outputDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support Record fetchOne(ResultSet rs, Class<?>... types) throws DataAccessException, InvalidResultException
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
rs - The JDBC ResultSet to fetch data fromtypes - The data types to use in the desired outputDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support Cursor<Record> fetchLazy(ResultSet rs) throws DataAccessException
ResultSet into a jOOQ Cursor.
Use fetch(ResultSet), to load the entire ResultSet
into a jOOQ Result at once.
rs - The JDBC ResultSet to fetch data fromDataAccessException - if something went wrong executing the query@Support Cursor<Record> fetchLazy(ResultSet rs, Field<?>... fields) throws DataAccessException
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
rs - The JDBC ResultSet to fetch data fromfields - The fields to use in the desired outputDataAccessException - if something went wrong executing the query@Support Cursor<Record> fetchLazy(ResultSet rs, DataType<?>... types) throws DataAccessException
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
rs - The JDBC ResultSet to fetch data fromtypes - The data types to use in the desired outputDataAccessException - if something went wrong executing the query@Support Cursor<Record> fetchLazy(ResultSet rs, Class<?>... types) throws DataAccessException
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
rs - The JDBC ResultSet to fetch data fromtypes - The data types to use in the desired outputDataAccessException - if something went wrong executing the query@Support Result<Record> fetchFromTXT(String string) throws DataAccessException
The supplied string is supposed to be formatted in a human-readable way.
This is the same as calling fetchFromTXT(string, "{null}")
string - The formatted stringDataAccessException - If the supplied string does not adhere to the
above format rules.fetchFromTXT(String, String)@Support Result<Record> fetchFromTXT(String string, String nullLiteral) throws DataAccessException
This method supports parsing results from two types of human-readable formats:
Result.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 |
+-----+-----+--------------------------+
VARCHAR(N) where
N = number of dashes per dash group
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
VARCHAR(N) where
N = number of dashes per dash groupBoth parsing methods make no assumption about the resulting data types. Instead, all data is string-based.
string - The formatted stringnullLiteral - The string literal to be used as null
value.DataAccessException - If the supplied string does not adhere to the
above format rules.@Support Result<Record> fetchFromCSV(String string) throws DataAccessException
This is the same as calling fetchFromCSV(string, ',') and
the inverse of calling Result.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
string - The CSV stringDataAccessException - If anything went wrong parsing the CSV filefetchFromCSV(String, char)@Support Result<Record> fetchFromCSV(String string, char delimiter) throws DataAccessException
This is inverse of calling Result.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
string - The CSV stringdelimiter - The delimiter to expect between recordsDataAccessException - If anything went wrong parsing the CSV filefetchFromCSV(String),
fetchFromStringData(List)Result<Record> fetchFromStringData(String[]... data)
This is used by methods such as
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 withnull.data - The data to be transformed into a ResultfetchFromStringData(List)Result<Record> fetchFromStringData(List<String[]> data)
This is used by methods such as
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 withnull.data - The data to be transformed into a Result@Support <R extends Record> SelectWhereStep<R> selectFrom(Table<R> table)
Example:
SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
@Support SelectSelectStep<Record> select(Collection<? extends Field<?>> fields)
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);
DSL.select(Collection)@Support SelectSelectStep<Record> select(Field<?>... fields)
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(Field...) 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();
DSL.select(Field...)@Generated(value="This method was generated using jOOQ-tools") @Support <T1> SelectSelectStep<Record1<T1>> select(Field<T1> field1)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Field.in(Select), Field.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field) instead.
Example:
using(configuration)
.select(field1)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2> SelectSelectStep<Record2<T1,T2>> select(Field<T1> field1, Field<T2> field2)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row2.in(Select), Row2.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field) instead.
Example:
using(configuration)
.select(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row3.in(Select), Row3.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row4.in(Select), Row4.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, field4)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row5.in(Select), Row5.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, field4, field5)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row6.in(Select), Row6.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field5, field6)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row7.in(Select), Row7.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field6, field7)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row8.in(Select), Row8.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field7, field8)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row9.in(Select), Row9.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field8, field9)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row10.in(Select), Row10.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field9, field10)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row11.in(Select), Row11.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field10, field11)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row12.in(Select), Row12.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field11, field12)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row13.in(Select), Row13.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field12, field13)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row14.in(Select), Row14.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field13, field14)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row15.in(Select), Row15.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field14, field15)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row16.in(Select), Row16.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field15, field16)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row17.in(Select), Row17.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field16, field17)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row18.in(Select), Row18.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field17, field18)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row19.in(Select), Row19.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field18, field19)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row20.in(Select), Row20.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field19, field20)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row21.in(Select), Row21.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field20, field21)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as select(Field...), except that it
declares additional record-level typesafety, which is needed by
Row22.in(Select), Row22.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.select(field1, field2, field3, .., field21, field22)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Support SelectSelectStep<Record> selectDistinct(Collection<? extends Field<?>> fields)
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);
DSL.selectDistinct(Collection)@Support SelectSelectStep<Record> selectDistinct(Field<?>... fields)
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(Field...) 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);
DSL.selectDistinct(Field...)@Generated(value="This method was generated using jOOQ-tools") @Support <T1> SelectSelectStep<Record1<T1>> selectDistinct(Field<T1> field1)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Field.in(Select), Field.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field) instead.
Example:
using(configuration)
.selectDistinct(field1)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2> SelectSelectStep<Record2<T1,T2>> selectDistinct(Field<T1> field1, Field<T2> field2)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row2.in(Select), Row2.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3> SelectSelectStep<Record3<T1,T2,T3>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row3.in(Select), Row3.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4> SelectSelectStep<Record4<T1,T2,T3,T4>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row4.in(Select), Row4.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, field4)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5> SelectSelectStep<Record5<T1,T2,T3,T4,T5>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row5.in(Select), Row5.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, field4, field5)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6> SelectSelectStep<Record6<T1,T2,T3,T4,T5,T6>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row6.in(Select), Row6.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field5, field6)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7> SelectSelectStep<Record7<T1,T2,T3,T4,T5,T6,T7>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row7.in(Select), Row7.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field6, field7)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8> SelectSelectStep<Record8<T1,T2,T3,T4,T5,T6,T7,T8>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row8.in(Select), Row8.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field7, field8)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9> SelectSelectStep<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row9.in(Select), Row9.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field8, field9)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> SelectSelectStep<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row10.in(Select), Row10.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field9, field10)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> SelectSelectStep<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row11.in(Select), Row11.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field10, field11)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> SelectSelectStep<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row12.in(Select), Row12.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field11, field12)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> SelectSelectStep<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row13.in(Select), Row13.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field12, field13)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> SelectSelectStep<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row14.in(Select), Row14.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field13, field14)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> SelectSelectStep<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row15.in(Select), Row15.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field14, field15)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> SelectSelectStep<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row16.in(Select), Row16.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field15, field16)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> SelectSelectStep<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row17.in(Select), Row17.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field16, field17)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> SelectSelectStep<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row18.in(Select), Row18.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field17, field18)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> SelectSelectStep<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row19.in(Select), Row19.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field18, field19)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> SelectSelectStep<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row20.in(Select), Row20.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field19, field20)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> SelectSelectStep<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row21.in(Select), Row21.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field20, field21)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Generated(value="This method was generated using jOOQ-tools") @Support <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> SelectSelectStep<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, 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)
This is the same as selectDistinct(Field...), except that it
declares additional record-level typesafety, which is needed by
Row22.in(Select), Row22.equal(Select) and other predicate
building methods taking subselect arguments.
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(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) instead.
Example:
using(configuration)
.selectDistinct(field1, field2, field3, .., field21, field22)
.from(table1)
.join(table2).on(field1.equal(field2))
.where(field1.greaterThan(100))
.orderBy(field2);
@Support SelectSelectStep<Record1<Integer>> selectZero()
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);
DSL.zero(),
DSL.selectZero()@Support SelectSelectStep<Record1<Integer>> selectOne()
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);
DSL.one(),
DSL.selectOne()@Support SelectSelectStep<Record1<Integer>> selectCount()
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);
DSL.selectCount()@Support SelectQuery<Record> selectQuery()
SelectQuery@Support <R extends Record> SelectQuery<R> selectQuery(TableLike<R> table)
SelectQuerytable - The table to select data fromSelectQuery@Support <R extends Record> InsertQuery<R> insertQuery(Table<R> into)
InsertQueryinto - The table to insert data intoInsertQuery@Support <R extends Record> InsertSetStep<R> insertInto(Table<R> into)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1> InsertValuesStep1<R,T1> insertInto(Table<R> into, Field<T1> field1)
Example:
using(configuration)
.insertInto(table, field1)
.values(field1)
.values(field1)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
.execute();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2> InsertValuesStep2<R,T1,T2> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2)
Example:
using(configuration)
.insertInto(table, field1, field2)
.values(field1, field2)
.values(field1, field2)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
.execute();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3> InsertValuesStep3<R,T1,T2,T3> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3)
Example:
using(configuration)
.insertInto(table, field1, field2, field3)
.values(field1, field2, field3)
.values(field1, field2, field3)
.onDuplicateKeyUpdate()
.set(field1, value1)
.set(field2, value2)
.execute();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4> InsertValuesStep4<R,T1,T2,T3,T4> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5> InsertValuesStep5<R,T1,T2,T3,T4,T5> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6> InsertValuesStep6<R,T1,T2,T3,T4,T5,T6> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7> InsertValuesStep7<R,T1,T2,T3,T4,T5,T6,T7> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> InsertValuesStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> InsertValuesStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> InsertValuesStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> InsertValuesStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> InsertValuesStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> InsertValuesStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> InsertValuesStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> InsertValuesStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> InsertValuesStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> InsertValuesStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> InsertValuesStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> InsertValuesStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> InsertValuesStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> InsertValuesStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
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();
@Generated(value="This method was generated using jOOQ-tools") @Support <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> InsertValuesStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
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();
@Support <R extends Record> InsertValuesStepN<R> insertInto(Table<R> into, Field<?>... fields)
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();
@Support <R extends Record> InsertValuesStepN<R> insertInto(Table<R> into, Collection<? extends Field<?>> fields)
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();
@Support <R extends Record> UpdateQuery<R> updateQuery(Table<R> table)
UpdateQuerytable - The table to update data intoUpdateQuery@Support <R extends Record> UpdateSetFirstStep<R> update(Table<R> table)
Example:
DSLContext create = DSL.using(configuration);
create.update(table)
.set(field1, value1)
.set(field2, value2)
.where(field1.greaterThan(100))
.execute();
Note that some databases support table expressions more complex than
simple table references. In CUBRID and MySQL, for instance, you can write
create.update(t1.join(t2).on(t1.id.eq(t2.id)))
.set(t1.value, value1)
.set(t2.value, value2)
.where(t1.id.eq(10))
.execute();
@Support(value={CUBRID,DB2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record> MergeUsingStep<R> mergeInto(Table<R> table)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| dialect | support type | documentation |
|---|---|---|
| CUBRID | SQL:2008 standard and some enhancements | http://www.cubrid.org/manual/90/en/MERGE |
| DB2 | SQL:2008 standard and major enhancements | http://publib.boulder.ibm.com/infocenter/db2luw/v9/index.jsp?topic=/com. ibm.db2.udb.admin.doc/doc/r0010873.htm |
| HSQLDB | SQL:2008 standard | http://hsqldb.org/doc/2.0/guide/dataaccess-chapt.html#N129BA |
| Oracle | SQL:2008 standard and minor enhancements | http://download.oracle.com/docs/cd/B28359_01/server.111/b28286/ statements_9016.htm |
| SQL Server | Similar to SQL:2008 standard with some major enhancements | http://msdn.microsoft.com/de-de/library/bb510625.aspx |
| Sybase | Similar to SQL:2008 standard with some major enhancements | http://dcx.sybase.com/1100/en/dbreference_en11/merge-statement.html |
Example:
DSLContext create = DSL.using(configuration);
create.mergeInto(table)
.using(select)
.on(condition)
.whenMatchedThenUpdate()
.set(field1, value1)
.set(field2, value2)
.whenNotMatchedThenInsert(field1, field2)
.values(value1, value2)
.execute();
Note: Using this method, you can also create an H2-specific MERGE
statement without field specification. See also
mergeInto(Table, Field...)
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1> MergeKeyStep1<R,T1> mergeInto(Table<R> table, Field<T1> field1)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2> MergeKeyStep2<R,T1,T2> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3> MergeKeyStep3<R,T1,T2,T3> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4> MergeKeyStep4<R,T1,T2,T3,T4> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5> MergeKeyStep5<R,T1,T2,T3,T4,T5> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6> MergeKeyStep6<R,T1,T2,T3,T4,T5,T6> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7> MergeKeyStep7<R,T1,T2,T3,T4,T5,T6,T7> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8> MergeKeyStep8<R,T1,T2,T3,T4,T5,T6,T7,T8> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9> MergeKeyStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> MergeKeyStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> MergeKeyStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> MergeKeyStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> MergeKeyStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> MergeKeyStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> MergeKeyStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> MergeKeyStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> MergeKeyStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> MergeKeyStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> MergeKeyStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> MergeKeyStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> MergeKeyStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Generated(value="This method was generated using jOOQ-tools") @Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> MergeKeyStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table, Field<?>... fields)
This statement is available from DSL syntax only. It is known to be supported in some way by any of these dialects:
| H2 | H2 natively supports this special syntax | www.h2database.com/html/grammar.html#merge |
| DB2, HSQLDB, Oracle, SQL Server, Sybase SQL Anywhere | These databases can simulate the H2-specific MERGE statement using a standard SQL MERGE statement, without restrictions | See mergeInto(Table) for the standard MERGE statement |
@Support(value={CUBRID,DB2,H2,HSQLDB,ORACLE,SQLSERVER,SYBASE}) <R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table, Collection<? extends Field<?>> fields)
mergeInto(Table, Field...)@Support <R extends Record> DeleteQuery<R> deleteQuery(Table<R> table)
DeleteQuerytable - The table to delete data fromDeleteQuery@Support <R extends Record> DeleteWhereStep<R> delete(Table<R> table)
Example:
DSLContext create = DSL.using(configuration);
create.delete(table)
.where(field1.greaterThan(100))
.execute();
Some but not all databases support aliased tables in delete statements.
@Support Batch batch(Query... queries)
This essentially runs the following logic:
Statement s = connection.createStatement();
for (Query query : queries) {
s.addBatch(query.getSQL(true));
}
s.execute();
Statement.executeBatch()@Support Batch batch(String... queries)
This is a convenience method for calling
batch(query(queries[0]), query(queries[1]), ...)
query(String),
batch(Query...),
Statement.executeBatch()@Support Batch batch(Collection<? extends Query> queries)
This essentially runs the following logic:
Statement s = connection.createStatement();
for (Query query : queries) {
s.addBatch(query.getSQL(true));
}
s.execute();
Statement.executeBatch()@Support BatchBindStep batch(Query query)
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
Statement.executeBatch()@Support BatchBindStep batch(String sql)
This is a convenience method for calling
batch(query(sql))
query(String),
batch(Query),
Statement.executeBatch()@Support Batch batch(Query query, Object[]... bindings)
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
batch(Query),
Statement.executeBatch()@Support Batch batch(String sql, Object[]... bindings)
This is a convenience method for calling
batch(query(sql), bindings)
@Support Batch batchStore(UpdatableRecord<?>... records)
INSERT and UPDATE queries in
batch mode (with bind values).
This batch operation can be executed in two modes:
Settings.getStatementType() == StatementType.PREPARED_STATEMENT
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();
result.length == 8 and
the following 4 separate batch statements:
Settings.getStatementType() == StatementType.STATIC_STATEMENTThis 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.
Statement.executeBatch()@Support Batch batchStore(Collection<? extends UpdatableRecord<?>> records)
INSERT and UPDATE queries in
batch mode (with bind values).@Support Batch batchInsert(UpdatableRecord<?>... records)
INSERT queries in batch mode (with bind
values).@Support Batch batchInsert(Collection<? extends UpdatableRecord<?>> records)
INSERT queries in batch mode (with bind
values).@Support Batch batchUpdate(UpdatableRecord<?>... records)
UPDATE queries in batch mode (with bind
values).@Support Batch batchUpdate(Collection<? extends UpdatableRecord<?>> records)
UPDATE queries in batch mode (with bind
values).@Support Batch batchDelete(UpdatableRecord<?>... records)
DELETE queries in batch mode (with bind
values).
This batch operation can be executed in two modes:
Settings.getStatementType() == StatementType.PREPARED_STATEMENT
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();
result.length == 8 and
the following 5 separate batch statements:
Settings.getStatementType() == StatementType.STATIC_STATEMENTThis 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.
Statement.executeBatch()@Support Batch batchDelete(Collection<? extends UpdatableRecord<?>> records)
DELETE in batch mode (with bind values).@Support <R extends Record> TruncateIdentityStep<R> truncate(Table<R> table)
Example:
DSLContext create = DSL.using(configuration);
create.truncate(table)
.execute();
TRUNCATE
Most dialects implement the TRUNCATE statement. If it is not
supported, it is simulated using an equivalent DELETE
statement. This is particularly true for these dialects:
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 simulated for those dialects that do not support them natively.
@Support(value={ASE,CUBRID,DERBY,H2,HSQLDB,INGRES,MARIADB,MYSQL,SQLITE,SQLSERVER,SYBASE}) BigInteger lastID() throws DataAccessException
Note, there are some restrictions to the following dialects:
SQLDialect.DB2 doesn't support thisSQLDialect.ORACLE doesn't support thisSQLDialect.POSTGRES doesn't support thisSQLDialect.SQLITE supports this, but its support is poorly
documented.null in some
dialects, if no such number is available.DataAccessException - if something went wrong executing the query@Support(value={CUBRID,DB2,DERBY,FIREBIRD,H2,HSQLDB,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE}) <T extends Number> T nextval(Sequence<T> sequence) throws DataAccessException
DSLContext's underlying JDBC ConnectionDataAccessException - if something went wrong executing the query@Support(value={CUBRID,DB2,FIREBIRD,H2,INGRES,ORACLE,POSTGRES,SQLSERVER2012,SYBASE}) <T extends Number> T currval(Sequence<T> sequence) throws DataAccessException
DSLContext's underlying JDBC ConnectionDataAccessException - if something went wrong executing the query<R extends UDTRecord<R>> R newRecord(UDT<R> type)
UDTRecord.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
R - The generic record typetype - The UDT describing records of type <R><R extends Record> R newRecord(Table<R> table)
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.
R - The generic record typetable - The table holding records of type <R><R extends Record> R newRecord(Table<R> table, Object source)
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.
R - The generic record typetable - The table holding records of type <R>source - The source to be used to fill the new recordMappingException - wrapping any reflection or data type conversion
exception that might have occurred while mapping recordsRecord.from(Object),
Record.into(Class)Record newRecord(Field<?>... fields)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
fields - The fields defining the Record type@Generated(value="This method was generated using jOOQ-tools") <T1> Record1<T1> newRecord(Field<T1> field1)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2> Record2<T1,T2> newRecord(Field<T1> field1, Field<T2> field2)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3> Record3<T1,T2,T3> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4> Record4<T1,T2,T3,T4> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5> Record5<T1,T2,T3,T4,T5> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6> Record6<T1,T2,T3,T4,T5,T6> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7> Record7<T1,T2,T3,T4,T5,T6,T7> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8> Record8<T1,T2,T3,T4,T5,T6,T7,T8> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9> Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
@Generated(value="This method was generated using jOOQ-tools") <T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
Record.
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
<R extends Record> Result<R> newResult(Table<R> table)
Result.
The result is attached to this Configuration by default. This
result can be used as a container for records.
R - The generic record typetable - The table holding records of type <R><R extends Record> Result<R> fetch(ResultQuery<R> query) throws DataAccessException
ResultQuery in the context of this executor and return
results.query - The query to executeDataAccessException - if something went wrong executing the queryResultQuery.fetch()<R extends Record> Cursor<R> fetchLazy(ResultQuery<R> query) throws DataAccessException
ResultQuery in the context of this executor and return
a cursor.query - The query to executeDataAccessException - if something went wrong executing the queryResultQuery.fetchLazy()<R extends Record> List<Result<Record>> fetchMany(ResultQuery<R> query) throws DataAccessException
ResultQuery in the context of this executor and return
a cursor.query - The query to executeDataAccessException - if something went wrong executing the queryResultQuery.fetchMany()<R extends Record> R fetchOne(ResultQuery<R> query) throws DataAccessException, InvalidResultException
ResultQuery in the context of this executor and return
a record.query - The query to executeDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one recordResultQuery.fetchOne()int fetchCount(Select<?> query) throws DataAccessException
Select query in the context of this executor 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%'
)
COUNT(*) OVER() window function to calculate
total results in paged queries.
query - The wrapped queryCOUNT(*) resultDataAccessException - if something went wrong executing the queryint execute(Query query) throws DataAccessException
Query in the context of this executor.query - The query to executeDataAccessException - if something went wrong executing the queryQuery.execute()@Support <R extends Record> Result<R> fetch(Table<R> table) throws DataAccessException
SELECT * FROM [table]
The result and its contained records are attached to this
Configuration by default. Use Settings.isAttachRecords()
to override this behaviour.
DataAccessException - if something went wrong executing the query@Support <R extends Record> Result<R> fetch(Table<R> table, Condition condition) throws DataAccessException
SELECT * FROM [table] WHERE [condition]
The result and its contained records are attached to this
Configuration by default. Use Settings.isAttachRecords()
to override this behaviour.
DataAccessException - if something went wrong executing the query@Support <R extends Record> R fetchOne(Table<R> table) throws DataAccessException, InvalidResultException
SELECT * FROM [table]
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
null if no record was returnedDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support <R extends Record> R fetchOne(Table<R> table, Condition condition) throws DataAccessException, InvalidResultException
SELECT * FROM [table] WHERE [condition]
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
null if no record was returnedDataAccessException - if something went wrong executing the queryInvalidResultException - if the query returned more than one record@Support <R extends Record> R fetchAny(Table<R> table) throws DataAccessException
SELECT * FROM [table] LIMIT 1
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
null if no record was returnedDataAccessException - if something went wrong executing the query@Support <R extends Record> R fetchAny(Table<R> table, Condition condition) throws DataAccessException
SELECT * FROM [table] WHERE [condition] LIMIT 1
The resulting record is attached to this Configuration by
default. Use Settings.isAttachRecords() to override this
behaviour.
null if no record was returnedDataAccessException - if something went wrong executing the query@Support <R extends Record> Cursor<R> fetchLazy(Table<R> table) throws DataAccessException
SELECT * FROM [table]
The result and its contained records are attached to this
Configuration by default. Use Settings.isAttachRecords()
to override this behaviour.
DataAccessException - if something went wrong executing the query@Support <R extends Record> Cursor<R> fetchLazy(Table<R> table, Condition condition) throws DataAccessException
SELECT * FROM [table] WHERE [condition]
The result and its contained records are attached to this
Configuration by default. Use Settings.isAttachRecords()
to override this behaviour.
DataAccessException - if something went wrong executing the query@Support <R extends TableRecord<R>> int executeInsert(R record) throws DataAccessException
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.
DataAccessException - if something went wrong executing the query@Support <R extends UpdatableRecord<R>> int executeUpdate(R record) throws DataAccessException
UPDATE [table] SET [modified values in record] WHERE [record is supplied record]
DataAccessException - if something went wrong executing the query@Support <R extends TableRecord<R>,T> int executeUpdate(R record, Condition condition) throws DataAccessException
UPDATE [table] SET [modified values in record] WHERE [condition]
DataAccessException - if something went wrong executing the query@Support <R extends UpdatableRecord<R>> int executeDelete(R record) throws DataAccessException
DELETE FROM [table] WHERE [record is supplied record]
DataAccessException - if something went wrong executing the query@Support <R extends TableRecord<R>,T> int executeDelete(R record, Condition condition) throws DataAccessException
DELETE FROM [table] WHERE [condition]
DataAccessException - if something went wrong executing the queryCopyright © 2013. All Rights Reserved.