Uses of Class
org.jooq.exception.DataAccessException

Packages that use DataAccessException

Package	Description
org.jooq	The org.jooq package contains jOOQ's public API.
org.jooq.exception	The org.jooq.exception package contains jOOQ's exceptions.
org.jooq.impl	The org.jooq.impl package contains jOOQ's implementation classes.

Uses of DataAccessException in org.jooq

Methods in org.jooq that return DataAccessException

Modifier and Type	Method and Description
DataAccessException	ResultOrRows.exception() The exception if applicable or null if there was no exception.
DataAccessException	LoaderError.exception() The underlying DataAccessException that caused the error.

Methods in org.jooq that throw DataAccessException

Modifier and Type	Method and Description
Connection	ConnectionProvider.acquire() Acquire a connection from the connection lifecycle handler.
void	SelectQuery.addJoinOnKey(TableLike<?> table, JoinType type) Joins the existing table product to a new table using a foreign key.
void	SelectQuery.addJoinOnKey(TableLike<?> table, JoinType type, TableField<?,?>... keyFields) Joins the existing table product to a new table using a foreign key.
void	TransactionProvider.begin(TransactionContext ctx) Begin a new transaction.
void	QueryPartInternal.bind(BindContext ctx) Deprecated. - 3.4.0 - [#2694] - Use QueryPartInternal.accept(Context) instead.
BindContext	BindContext.bind(Collection<? extends QueryPart> parts) Deprecated. - 3.2.0 - [#2666] - Use Context.visit(QueryPart) instead
BindContext	BindContext.bind(QueryPart part) Deprecated. - 3.2.0 - [#2666] - Use Context.visit(QueryPart) instead
BindContext	BindContext.bind(QueryPart[] parts) Deprecated. - 3.2.0 - [#2666] - Use Context.visit(QueryPart) instead
BindContext	BindContext.bindValue(Object value, Class<?> type) Deprecated. - 3.4.0 - [#3114] - Use BindContext.bindValue(Object, Field) instead
BindContext	Context.bindValue(Object value, Field<?> field) Bind a value using a specific type.
BindContext	BindContext.bindValue(Object value, Field<?> field) Bind a value using a specific type.
BindContext	BindContext.bindValues(Object... values) Deprecated. - 3.4.0 - [#3114] - Use BindContext.bindValue(Object, Field) instead
void	Query.cancel() Cancel the underlying statement.
void	Query.close() Close the underlying statement.
void	DSLContext.close() Close the underlying resources, if any resources have been allocated when constructing this DSLContext.
void	Cursor.close() Explicitly close the underlying PreparedStatement and ResultSet.
<X,A> X	ResultQuery.collect(Collector<? super R,A,X> collector) Reduce the execution results of this query using a Collector.
<X,A> X	Cursor.collect(Collector<? super R,A,X> collector) Reduce the execution results of this query using a Collector.
void	TransactionProvider.commit(TransactionContext ctx) Commit a transaction.
long	DAO.count() Count all records of the underlying table.
BigInteger	DSLContext.currval(Name sequence) Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.
<T extends Number> T	DSLContext.currval(Sequence<T> sequence) Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.
BigInteger	DSLContext.currval(String sequence) Convenience method to fetch the CURRVAL for a sequence directly from this DSLContext's underlying JDBC Connection.
int	UpdatableRecord.delete() Deletes this record from the database, based on the value of the primary key or main unique key.
void	DAO.delete(Collection<P> objects) Performs a DELETE statement for a given set of POJOs
void	DAO.delete(P... objects) Performs a DELETE statement for a given set of POJOs
void	DAO.delete(P object) Performs a DELETE statement for a POJO
void	DAO.deleteById(Collection<T> ids) Performs a DELETE statement for a given set of IDs
void	DAO.deleteById(T... ids) Performs a DELETE statement for a given set of IDs
int	Routine.execute() Execute the stored object on an underlying connection
int	Query.execute() Execute the query, if it has been created with a proper configuration.
int[]	Batch.execute() Execute the batch operation.
int	Routine.execute(Configuration configuration) Execute the stored object using a Configuration object
int	DSLContext.execute(Query query) Execute a Query in the context of this DSLContext.
int	DSLContext.execute(SQL sql) Execute a query holding plain SQL.
int	DSLContext.execute(String sql) Execute a query holding plain SQL.
int	DSLContext.execute(String sql, Object... bindings) Execute a new query holding plain SQL.
int	DSLContext.execute(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<R extends UpdatableRecord<R>> int	DSLContext.executeDelete(R record) Delete a record from a table.
<R extends TableRecord<R>,T> int	DSLContext.executeDelete(R record, Condition condition) Delete a record from a table.
<R extends TableRecord<R>> int	DSLContext.executeInsert(R record) Insert one record.
<R extends UpdatableRecord<R>> int	DSLContext.executeUpdate(R record) Update a table.
<R extends TableRecord<R>,T> int	DSLContext.executeUpdate(R record, Condition condition) Update a table.
boolean	DAO.exists(P object) Checks if a given POJO exists
boolean	DAO.existsById(T id) Checks if a given ID exists
Result<R>	UpdateResultStep.fetch() The result holding returned values as specified by the UpdateReturningStep.
Result<R>	ResultQuery.fetch() Execute the query and return the generated result.
Result<R>	InsertResultStep.fetch() The result holding returned values as specified by the InsertReturningStep.
Result<R>	DeleteResultStep.fetch() The result holding returned values as specified by the DeleteReturningStep.
Result<R>	Cursor.fetch() Fetch all remaining records as a result.
<T> List<T>	ResultQuery.fetch(Field<?> field, Class<? extends T> type) Execute the query and return all values for a field from the generated result.
<T> List<T>	ResultQuery.fetch(Field<T> field) Execute the query and return all values for a field from the generated result.
<T,U> List<U>	ResultQuery.fetch(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return all values for a field from the generated result.
<Z> List<P>	DAO.fetch(Field<Z> field, Z... values) Find records by a given field and a set of values.
List<?>	ResultQuery.fetch(int fieldIndex) Execute the query and return all values for a field index from the generated result.
Result<R>	Cursor.fetch(int number) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNext(int) instead.
<T> List<T>	ResultQuery.fetch(int fieldIndex, Class<? extends T> type) Execute the query and return all values for a field index from the generated result.
<U> List<U>	ResultQuery.fetch(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return all values for a field index from the generated result.
List<?>	ResultQuery.fetch(Name fieldName) Execute the query and return all values for a field name from the generated result.
<T> List<T>	ResultQuery.fetch(Name fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> List<U>	ResultQuery.fetch(Name fieldName, Converter<?,? extends U> converter) Execute the query and return all values for a field name from the generated result.
<E> List<E>	ResultQuery.fetch(RecordMapper<? super R,E> mapper) Fetch results into a custom mapper callback.
<E> List<E>	Cursor.fetch(RecordMapper<? super R,E> mapper) Fetch results into a custom mapper callback.
<R extends Record> Result<R>	DSLContext.fetch(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return results.
Result<Record>	DSLContext.fetch(ResultSet rs) Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
Result<Record>	DSLContext.fetch(ResultSet rs, Class<?>... types) Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
Result<Record>	DSLContext.fetch(ResultSet rs, DataType<?>... types) Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
Result<Record>	DSLContext.fetch(ResultSet rs, Field<?>... fields) Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
Result<Record>	DSLContext.fetch(SQL sql) Execute a new query holding plain SQL.
List<?>	ResultQuery.fetch(String fieldName) Execute the query and return all values for a field name from the generated result.
Result<Record>	DSLContext.fetch(String sql) Execute a new query holding plain SQL.
<T> List<T>	ResultQuery.fetch(String fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> List<U>	ResultQuery.fetch(String fieldName, Converter<?,? extends U> converter) Execute the query and return all values for a field name from the generated result.
Result<Record>	DSLContext.fetch(String sql, Object... bindings) Execute a new query holding plain SQL.
Result<Record>	DSLContext.fetch(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<R extends Record> Result<R>	DSLContext.fetch(Table<R> table) Execute and return all records for SELECT * FROM [table].
<R extends Record> Result<R>	DSLContext.fetch(Table<R> table, Condition condition) Execute and return all records for SELECT * FROM [table] WHERE [condition] .
R	ResultQuery.fetchAny() Execute the query and return at most one resulting record.
<T> T	ResultQuery.fetchAny(Field<?> field, Class<? extends T> type) Execute the query and return at most one resulting value for a field from the generated result.
<T> T	ResultQuery.fetchAny(Field<T> field) Execute the query and return at most one resulting value for a field from the generated result.
<T,U> U	ResultQuery.fetchAny(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return at most one resulting value for a field from the generated result.
Object	ResultQuery.fetchAny(int fieldIndex) Execute the query and return at most one resulting value for a field index from the generated result.
<T> T	ResultQuery.fetchAny(int fieldIndex, Class<? extends T> type) Execute the query and return at most one resulting value for a field index from the generated result.
<U> U	ResultQuery.fetchAny(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field index from the generated result.
Object	ResultQuery.fetchAny(Name fieldName) Execute the query and return at most one resulting value for a field name from the generated result.
<T> T	ResultQuery.fetchAny(Name fieldName, Class<? extends T> type) Execute the query and return at most one resulting value for a field name from the generated result.
<U> U	ResultQuery.fetchAny(Name fieldName, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field name from the generated result.
<E> E	ResultQuery.fetchAny(RecordMapper<? super R,E> mapper) Execute the query and return at most one resulting record.
Object	ResultQuery.fetchAny(String fieldName) Execute the query and return at most one resulting value for a field name from the generated result.
<T> T	ResultQuery.fetchAny(String fieldName, Class<? extends T> type) Execute the query and return at most one resulting value for a field name from the generated result.
<U> U	ResultQuery.fetchAny(String fieldName, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field name from the generated result.
<R extends Record> R	DSLContext.fetchAny(Table<R> table) Execute and return zero or one record for SELECT * FROM [table] LIMIT 1.
<R extends Record> R	DSLContext.fetchAny(Table<R> table, Condition condition) Execute and return zero or one record for SELECT * FROM [table] WHERE [condition] LIMIT 1.
Object[]	ResultQuery.fetchAnyArray() Execute the query and return at most one resulting record as an array You can access data like this query.fetchAnyArray()[fieldIndex]
<E> E	ResultQuery.fetchAnyInto(Class<? extends E> type) Map resulting records onto a custom type.
<Z extends Record> Z	ResultQuery.fetchAnyInto(Table<Z> table) Map resulting records onto a custom record.
Map<String,Object>	ResultQuery.fetchAnyMap() Execute the query and return at most one resulting record as a name/value map.
R[]	ResultQuery.fetchArray() Execute the query and return the generated result as an array of records.
<T> T[]	ResultQuery.fetchArray(Field<?> field, Class<? extends T> type) Execute the query and return all values for a field from the generated result.
<T> T[]	ResultQuery.fetchArray(Field<T> field) Execute the query and return all values for a field from the generated result.
<T,U> U[]	ResultQuery.fetchArray(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return all values for a field from the generated result.
Object[]	ResultQuery.fetchArray(int fieldIndex) Execute the query and return all values for a field index from the generated result.
<T> T[]	ResultQuery.fetchArray(int fieldIndex, Class<? extends T> type) Execute the query and return all values for a field index from the generated result.
<U> U[]	ResultQuery.fetchArray(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return all values for a field index from the generated result.
Object[]	ResultQuery.fetchArray(Name fieldName) Execute the query and return all values for a field name from the generated result.
<T> T[]	ResultQuery.fetchArray(Name fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> U[]	ResultQuery.fetchArray(Name fieldName, Converter<?,? extends U> converter) Execute the query and return all values for a field name from the generated result.
Object[]	ResultQuery.fetchArray(String fieldName) Execute the query and return all values for a field name from the generated result.
<T> T[]	ResultQuery.fetchArray(String fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> U[]	ResultQuery.fetchArray(String fieldName, Converter<?,? extends U> converter) Execute the query and return all values for a field name from the generated result.
Object[][]	ResultQuery.fetchArrays() Execute the query and return the generated result as an Object matrix.
<R extends TableRecord<R>> Result<R>	DSLContext.fetchByExample(R example) Execute a "Query by Example" (QBE) based on an example record.
<O extends TableRecord<O>> O	UpdatableRecord.fetchChild(ForeignKey<O,R> key) Fetch a child record of this record, given a foreign key.
Result<R>	ForeignKey.fetchChildren(Collection<? extends O> records) Fetch child records of a given set of records through this foreign key This returns childs record referencing any record in a given set of records through this foreign key
<O extends TableRecord<O>> Result<O>	UpdatableRecord.fetchChildren(ForeignKey<O,R> key) Fetch child records of this record, given a foreign key.
<O extends TableRecord<O>> Result<O>	Result.fetchChildren(ForeignKey<O,R> key) Fetch child records of this record, given a foreign key.
Result<R>	ForeignKey.fetchChildren(O... records) Fetch child records of a given set of records through this foreign key This returns childs record referencing any record in a given set of records through this foreign key
Result<R>	ForeignKey.fetchChildren(O record) Fetch child records of a given record through this foreign key This returns childs record referencing a given record through this foreign key
int	Select.fetchCount() Deprecated. - 3.5.0 - [#3356] - This method is being removed as it is confusingly different from all the other types of ResultQuery.fetch() methods, in that it modifies the original Select statement by wrapping it. In particular, this method can be easily confused with ResultQuery.fetch(Field), or more concretely fetch(count()), which has an entirely different semantics. Use DSLContext.fetchCount(Select) instead.
int	DSLContext.fetchCount(Select<?> query) Execute a Select query in the context of this DSLContext and return a COUNT(*) value.
int	DSLContext.fetchCount(Table<?> table) Count the number of records in a table.
int	DSLContext.fetchCount(Table<?> table, Condition condition) Count the number of records in a table that satisfy a condition.
boolean	DSLContext.fetchExists(Select<?> query) Check if a Select would return any records, if it were executed.
boolean	DSLContext.fetchExists(Table<?> table) Check if a table has any records.
boolean	DSLContext.fetchExists(Table<?> table, Condition condition) Check if a table has any records that satisfy a condition.
Result<Record>	DSLContext.fetchFromCSV(String string) Fetch all data from a CSV string.
Result<Record>	DSLContext.fetchFromCSV(String string, boolean header) Fetch all data from a CSV string.
Result<Record>	DSLContext.fetchFromCSV(String string, boolean header, char delimiter) Fetch all data from a CSV string.
Result<Record>	DSLContext.fetchFromCSV(String string, char delimiter) Fetch all data from a CSV string.
Result<Record>	DSLContext.fetchFromHTML(String string) Convert an HTML table into a jOOQ Result.
Result<Record>	DSLContext.fetchFromTXT(String string) Fetch all data from a formatted string.
Result<Record>	DSLContext.fetchFromTXT(String string, String nullLiteral) Fetch all data from a formatted string.
Map<Record,Result<R>>	ResultQuery.fetchGroups(Field<?>[] keys) Execute the query and return a Map with the result grouped by the given keys.
Map<Record,Result<Record>>	ResultQuery.fetchGroups(Field<?>[] keys, Field<?>[] values) Execute the query and return a Map with the result grouped by the given keys.
<K> Map<K,Result<R>>	ResultQuery.fetchGroups(Field<K> key) Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
<K,E> Map<K,List<E>>	ResultQuery.fetchGroups(Field<K> key, Class<? extends E> type) Return a Map with results grouped by the given key and mapped into the given entity type.
<K,V> Map<K,List<V>>	ResultQuery.fetchGroups(Field<K> key, Field<V> value) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value Unlike ResultQuery.fetchMap(Field, Field), this method allows for non-unique keys in the result set.
<K,E> Map<K,List<E>>	ResultQuery.fetchGroups(Field<K> key, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,Result<R>>	ResultQuery.fetchGroups(int keyFieldIndex) Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
Map<Record,Result<R>>	ResultQuery.fetchGroups(int[] keyFieldIndexes) Execute the query and return a Map with the result grouped by the given keys.
Map<Record,Result<Record>>	ResultQuery.fetchGroups(int[] keyFieldIndexes, int[] valueFieldIndexes) Execute the query and return a Map with the result grouped by the given keys.
<E> Map<?,List<E>>	ResultQuery.fetchGroups(int keyFieldIndex, Class<? extends E> type) Return a Map with results grouped by the given key and mapped into the given entity type.
Map<?,List<?>>	ResultQuery.fetchGroups(int keyFieldIndex, int valueFieldIndex) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value Unlike ResultQuery.fetchMap(int, int), this method allows for non-unique keys in the result set.
<E> Map<?,List<E>>	ResultQuery.fetchGroups(int keyFieldIndex, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,Result<R>>	ResultQuery.fetchGroups(Name keyFieldName) Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
Map<Record,Result<R>>	ResultQuery.fetchGroups(Name[] keyFieldNames) Execute the query and return a Map with the result grouped by the given keys.
Map<Record,Result<Record>>	ResultQuery.fetchGroups(Name[] keyFieldNames, Name[] valueFieldNames) Execute the query and return a Map with the result grouped by the given keys.
<E> Map<?,List<E>>	ResultQuery.fetchGroups(Name keyFieldName, Class<? extends E> type) Return a Map with results grouped by the given key and mapped into the given entity type.
Map<?,List<?>>	ResultQuery.fetchGroups(Name keyFieldName, Name valueFieldName) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value Unlike ResultQuery.fetchMap(Name, Name), this method allows for non-unique keys in the result set.
<E> Map<?,List<E>>	ResultQuery.fetchGroups(Name keyFieldName, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,Result<R>>	ResultQuery.fetchGroups(String keyFieldName) Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
Map<Record,Result<R>>	ResultQuery.fetchGroups(String[] keyFieldNames) Execute the query and return a Map with the result grouped by the given keys.
Map<Record,Result<Record>>	ResultQuery.fetchGroups(String[] keyFieldNames, String[] valueFieldNames) Execute the query and return a Map with the result grouped by the given keys.
<E> Map<?,List<E>>	ResultQuery.fetchGroups(String keyFieldName, Class<? extends E> type) Return a Map with results grouped by the given key and mapped into the given entity type.
<E> Map<?,List<E>>	ResultQuery.fetchGroups(String keyFieldName, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,List<?>>	ResultQuery.fetchGroups(String keyFieldName, String valueFieldName) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value Unlike ResultQuery.fetchMap(String, String), this method allows for non-unique keys in the result set.
<S extends Record> Map<S,Result<R>>	ResultQuery.fetchGroups(Table<S> table) Execute the query and return a Map with the result grouped by the given table.
<E,S extends Record> Map<S,List<E>>	ResultQuery.fetchGroups(Table<S> table, Class<? extends E> type) Execute the query and return a Map with results grouped by the given table and mapped into the given entity type.
<E,S extends Record> Map<S,List<E>>	ResultQuery.fetchGroups(Table<S> table, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given table and mapped by the given mapper.
<S extends Record,T extends Record> Map<S,Result<T>>	ResultQuery.fetchGroups(Table<S> keyTable, Table<T> valueTable) Execute the query and return a Map with the result grouped by the given table.
<E> List<E>	ResultQuery.fetchInto(Class<? extends E> type) Map resulting records onto a custom type.
<E> List<E>	Cursor.fetchInto(Class<? extends E> type) Map resulting records onto a custom type.
<H extends RecordHandler<? super R>> H	ResultQuery.fetchInto(H handler) Fetch results into a custom handler callback.
<H extends RecordHandler<? super R>> H	Cursor.fetchInto(H handler) Fetch results into a custom handler callback.
<Z extends Record> Result<Z>	ResultQuery.fetchInto(Table<Z> table) Map resulting records onto a custom record.
<Z extends Record> Result<Z>	Cursor.fetchInto(Table<Z> table) Map resulting records onto a custom record.
FutureResult<R>	ResultQuery.fetchLater() Deprecated. - 3.2.0 - [#2581] - This method will be removed in jOOQ 4.0
FutureResult<R>	ResultQuery.fetchLater(ExecutorService executor) Deprecated. - 3.2.0 - [#2581] - This method will be removed in jOOQ 4.0
Cursor<R>	ResultQuery.fetchLazy() Execute the query and "lazily" return the generated result.
Cursor<R>	ResultQuery.fetchLazy(int fetchSize) Deprecated. - [#2811] - 3.3.0 - Use ResultQuery.fetchSize(int) and ResultQuery.fetchLazy() instead.
<R extends Record> Cursor<R>	DSLContext.fetchLazy(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a cursor.
Cursor<Record>	DSLContext.fetchLazy(ResultSet rs) Wrap a JDBC ResultSet into a jOOQ Cursor.
Cursor<Record>	DSLContext.fetchLazy(ResultSet rs, Class<?>... types) Wrap a JDBC ResultSet into a jOOQ Cursor.
Cursor<Record>	DSLContext.fetchLazy(ResultSet rs, DataType<?>... types) Wrap a JDBC ResultSet into a jOOQ Cursor.
Cursor<Record>	DSLContext.fetchLazy(ResultSet rs, Field<?>... fields) Wrap a JDBC ResultSet into a jOOQ Cursor.
Cursor<Record>	DSLContext.fetchLazy(SQL sql) Execute a new query holding plain SQL and "lazily" return the generated result.
Cursor<Record>	DSLContext.fetchLazy(String sql) Execute a new query holding plain SQL and "lazily" return the generated result.
Cursor<Record>	DSLContext.fetchLazy(String sql, Object... bindings) Execute a new query holding plain SQL and "lazily" return the generated result.
Cursor<Record>	DSLContext.fetchLazy(String sql, QueryPart... parts) Execute a new query holding plain SQL and "lazily" return the generated result.
<R extends Record> Cursor<R>	DSLContext.fetchLazy(Table<R> table) Execute and return all records lazily for SELECT * FROM [table].
<R extends Record> Cursor<R>	DSLContext.fetchLazy(Table<R> table, Condition condition) Execute and return all records lazily for SELECT * FROM [table] WHERE [condition] .
Results	ResultQuery.fetchMany() Execute a query, possibly returning several result sets.
<R extends Record> Results	DSLContext.fetchMany(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a cursor.
Results	DSLContext.fetchMany(SQL sql) Execute a new query holding plain SQL, possibly returning several result sets.
Results	DSLContext.fetchMany(String sql) Execute a new query holding plain SQL, possibly returning several result sets.
Results	DSLContext.fetchMany(String sql, Object... bindings) Execute a new query holding plain SQL, possibly returning several result sets.
Results	DSLContext.fetchMany(String sql, QueryPart... parts) Execute a new query holding plain SQL, possibly returning several result sets.
<K> Map<K,R>	ResultQuery.fetchMap(Class<? extends K> keyType) Execute the query and return a Map with results grouped by the given key entity.
<K,V> Map<K,V>	ResultQuery.fetchMap(Class<? extends K> keyType, Class<? extends V> valueType) Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
<K,V> Map<K,V>	ResultQuery.fetchMap(Class<? extends K> keyType, RecordMapper<? super R,V> valueMapper) Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
Map<Record,R>	ResultQuery.fetchMap(Field<?>[] keys) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(Field<?>[] keys, Class<? extends E> type) Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
Map<Record,Record>	ResultQuery.fetchMap(Field<?>[] keys, Field<?>[] values) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(Field<?>[] keys, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
<K> Map<K,R>	ResultQuery.fetchMap(Field<K> key) Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
<K,E> Map<K,E>	ResultQuery.fetchMap(Field<K> key, Class<? extends E> type) Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
<K,V> Map<K,V>	ResultQuery.fetchMap(Field<K> key, Field<V> value) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value An exception is thrown, if the key turns out to be non-unique in the result set.
<K,E> Map<K,E>	ResultQuery.fetchMap(Field<K> key, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,R>	ResultQuery.fetchMap(int keyFieldIndex) Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
Map<Record,R>	ResultQuery.fetchMap(int[] keyFieldIndexes) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(int[] keyFieldIndexes, Class<? extends E> type) Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
Map<Record,Record>	ResultQuery.fetchMap(int[] keyFieldIndexes, int[] valueFieldIndexes) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(int[] keyFieldIndexes, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
<E> Map<?,E>	ResultQuery.fetchMap(int keyFieldIndex, Class<? extends E> type) Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
Map<?,?>	ResultQuery.fetchMap(int keyFieldIndex, int valueFieldIndex) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value An exception is thrown, if the key turns out to be non-unique in the result set.
<E> Map<?,E>	ResultQuery.fetchMap(int keyFieldIndex, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,R>	ResultQuery.fetchMap(Name keyFieldName) Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
Map<Record,R>	ResultQuery.fetchMap(Name[] keyFieldNames) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(Name[] keyFieldNames, Class<? extends E> type) Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
Map<Record,Record>	ResultQuery.fetchMap(Name[] keyFieldNames, Name[] valueFieldNames) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(Name[] keyFieldNames, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
<E> Map<?,E>	ResultQuery.fetchMap(Name keyFieldName, Class<? extends E> type) Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
Map<?,?>	ResultQuery.fetchMap(Name keyFieldName, Name valueFieldName) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value An exception is thrown, if the key turns out to be non-unique in the result set.
<E> Map<?,E>	ResultQuery.fetchMap(Name keyFieldName, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
<K> Map<K,R>	ResultQuery.fetchMap(RecordMapper<? super R,K> keyMapper) Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
<K,V> Map<K,V>	ResultQuery.fetchMap(RecordMapper<? super R,K> keyMapper, Class<V> valueType) Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
<K,V> Map<K,V>	ResultQuery.fetchMap(RecordMapper<? super R,K> keyMapper, RecordMapper<? super R,V> valueMapper) Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
Map<?,R>	ResultQuery.fetchMap(String keyFieldName) Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
Map<Record,R>	ResultQuery.fetchMap(String[] keyFieldNames) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	ResultQuery.fetchMap(String[] keyFieldNames, Class<? extends E> type) Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
<E> Map<List<?>,E>	ResultQuery.fetchMap(String[] keyFieldNames, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
Map<Record,Record>	ResultQuery.fetchMap(String[] keyFieldNames, String[] valueFieldNames) Execute the query and return a Map with keys as a map key and the corresponding record as value.
<E> Map<?,E>	ResultQuery.fetchMap(String keyFieldName, Class<? extends E> type) Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
<E> Map<?,E>	ResultQuery.fetchMap(String keyFieldName, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
Map<?,?>	ResultQuery.fetchMap(String keyFieldName, String valueFieldName) Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value An exception is thrown, if the key turns out to be non-unique in the result set.
<S extends Record> Map<S,R>	ResultQuery.fetchMap(Table<S> table) Execute the query and return a Map with table as a map key and the corresponding record as value.
<E,S extends Record> Map<S,E>	ResultQuery.fetchMap(Table<S> table, Class<? extends E> type) Execute the query and return a Map with results grouped by the given table and mapped into the given entity type.
<E,S extends Record> Map<S,E>	ResultQuery.fetchMap(Table<S> table, RecordMapper<? super R,E> mapper) Execute the query and return a Map with results grouped by the given table and mapped by the given mapper.
<S extends Record,T extends Record> Map<S,T>	ResultQuery.fetchMap(Table<S> keyTable, Table<T> valueTable) Execute the query and return a Map with table as a map key and the corresponding record as value.
List<Map<String,Object>>	ResultQuery.fetchMaps() Execute the query and return the generated result as a list of name/value maps.
R	Cursor.fetchNext() Fetch the next record from the cursor.
Result<R>	Cursor.fetchNext(int number) Fetch the next couple of records from the cursor.
<E> E	Cursor.fetchNext(RecordMapper<? super R,E> mapper) Fetch the next record into a custom mapper callback.
<E> E	Cursor.fetchNextInto(Class<? extends E> type) Map the next resulting record onto a custom type.
<H extends RecordHandler<? super R>> H	Cursor.fetchNextInto(H handler) Fetch the next record into a custom handler callback.
<Z extends Record> Z	Cursor.fetchNextInto(Table<Z> table) Map the next resulting record onto a custom record.
Optional<R>	Cursor.fetchNextOptional() Fetch the next record from the cursor.
<E> Optional<E>	Cursor.fetchNextOptional(RecordMapper<? super R,E> mapper) Fetch the next record into a custom mapper callback.
<E> Optional<E>	Cursor.fetchNextOptionalInto(Class<? extends E> type) Map the next resulting record onto a custom type.
<Z extends Record> Optional<Z>	Cursor.fetchNextOptionalInto(Table<Z> table) Map the next resulting record onto a custom record.
R	UpdateResultStep.fetchOne() The record holding returned values as specified by the UpdateReturningStep.
R	ResultQuery.fetchOne() Execute the query and return at most one resulting record.
R	InsertResultStep.fetchOne() The record holding returned values as specified by the InsertReturningStep.
R	DeleteResultStep.fetchOne() The record holding returned values as specified by the DeleteReturningStep.
R	Cursor.fetchOne() Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNext() instead.
<T> T	ResultQuery.fetchOne(Field<?> field, Class<? extends T> type) Execute the query and return at most one resulting value for a field from the generated result.
<T> T	ResultQuery.fetchOne(Field<T> field) Execute the query and return at most one resulting value for a field from the generated result.
<T,U> U	ResultQuery.fetchOne(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return at most one resulting value for a field from the generated result.
<Z> P	DAO.fetchOne(Field<Z> field, Z value) Find a unique record by a given field and a value.
Object	ResultQuery.fetchOne(int fieldIndex) Execute the query and return at most one resulting value for a field index from the generated result.
<T> T	ResultQuery.fetchOne(int fieldIndex, Class<? extends T> type) Execute the query and return at most one resulting value for a field index from the generated result.
<U> U	ResultQuery.fetchOne(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field index from the generated result.
Object	ResultQuery.fetchOne(Name fieldName) Execute the query and return at most one resulting value for a field name from the generated result.
<T> T	ResultQuery.fetchOne(Name fieldName, Class<? extends T> type) Execute the query and return at most one resulting value for a field name from the generated result.
<U> U	ResultQuery.fetchOne(Name fieldName, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field name from the generated result.
<E> E	ResultQuery.fetchOne(RecordMapper<? super R,E> mapper) Execute the query and return at most one resulting value into a custom mapper callback.
<E> E	Cursor.fetchOne(RecordMapper<? super R,E> mapper) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNext(RecordMapper) instead.
<R extends Record> R	DSLContext.fetchOne(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a record.
Record	DSLContext.fetchOne(ResultSet rs) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchOne(ResultSet rs, Class<?>... types) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchOne(ResultSet rs, DataType<?>... types) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchOne(ResultSet rs, Field<?>... fields) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchOne(SQL sql) Execute a new query holding plain SQL.
Object	ResultQuery.fetchOne(String fieldName) Execute the query and return at most one resulting value for a field name from the generated result.
Record	DSLContext.fetchOne(String sql) Execute a new query holding plain SQL.
<T> T	ResultQuery.fetchOne(String fieldName, Class<? extends T> type) Execute the query and return at most one resulting value for a field name from the generated result.
<U> U	ResultQuery.fetchOne(String fieldName, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field name from the generated result.
Record	DSLContext.fetchOne(String sql, Object... bindings) Execute a new query holding plain SQL.
Record	DSLContext.fetchOne(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<R extends Record> R	DSLContext.fetchOne(Table<R> table) Execute and return zero or one record for SELECT * FROM [table].
<R extends Record> R	DSLContext.fetchOne(Table<R> table, Condition condition) Execute and return zero or one record for SELECT * FROM [table] WHERE [condition] .
Object[]	ResultQuery.fetchOneArray() Execute the query and return at most one resulting record as an array You can access data like this query.fetchOneArray()[fieldIndex]
<E> E	ResultQuery.fetchOneInto(Class<? extends E> type) Map resulting records onto a custom type.
<E> E	Cursor.fetchOneInto(Class<? extends E> type) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextInto(Class) instead.
<H extends RecordHandler<? super R>> H	Cursor.fetchOneInto(H handler) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextInto(RecordHandler) instead.
<Z extends Record> Z	ResultQuery.fetchOneInto(Table<Z> table) Map resulting records onto a custom record.
<Z extends Record> Z	Cursor.fetchOneInto(Table<Z> table) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextInto(Table) instead.
Map<String,Object>	ResultQuery.fetchOneMap() Execute the query and return at most one resulting record as a name/value map.
Optional<R>	UpdateResultStep.fetchOptional() The record holding returned values as specified by the UpdateReturningStep.
Optional<R>	ResultQuery.fetchOptional() Execute the query and return at most one resulting record.
Optional<R>	InsertResultStep.fetchOptional() The record holding returned values as specified by the InsertReturningStep.
Optional<R>	DeleteResultStep.fetchOptional() The record holding returned values as specified by the DeleteReturningStep.
Optional<R>	Cursor.fetchOptional() Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextOptional() instead.
<T> Optional<T>	ResultQuery.fetchOptional(Field<?> field, Class<? extends T> type) Execute the query and return at most one resulting value for a field from the generated result.
<T> Optional<T>	ResultQuery.fetchOptional(Field<T> field) Execute the query and return at most one resulting value for a field from the generated result.
<T,U> Optional<U>	ResultQuery.fetchOptional(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return at most one resulting value for a field from the generated result.
<Z> Optional<P>	DAO.fetchOptional(Field<Z> field, Z value) Find a unique record by a given field and a value.
Optional<?>	ResultQuery.fetchOptional(int fieldIndex) Execute the query and return at most one resulting value for a field index from the generated result.
<T> Optional<T>	ResultQuery.fetchOptional(int fieldIndex, Class<? extends T> type) Execute the query and return at most one resulting value for a field index from the generated result.
<U> Optional<U>	ResultQuery.fetchOptional(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field index from the generated result.
Optional<?>	ResultQuery.fetchOptional(Name fieldName) Execute the query and return at most one resulting value for a field name from the generated result.
<T> Optional<T>	ResultQuery.fetchOptional(Name fieldName, Class<? extends T> type) Execute the query and return at most one resulting value for a field name from the generated result.
<U> Optional<U>	ResultQuery.fetchOptional(Name fieldName, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field name from the generated result.
<E> Optional<E>	ResultQuery.fetchOptional(RecordMapper<? super R,E> mapper) Execute the query and return at most one resulting value into a custom mapper callback.
<E> Optional<E>	Cursor.fetchOptional(RecordMapper<? super R,E> mapper) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextOptional(RecordMapper) instead.
<R extends Record> Optional<R>	DSLContext.fetchOptional(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a record.
Optional<Record>	DSLContext.fetchOptional(ResultSet rs) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Optional<Record>	DSLContext.fetchOptional(ResultSet rs, Class<?>... types) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Optional<Record>	DSLContext.fetchOptional(ResultSet rs, DataType<?>... types) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Optional<Record>	DSLContext.fetchOptional(ResultSet rs, Field<?>... fields) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Optional<Record>	DSLContext.fetchOptional(SQL sql) Execute a new query holding plain SQL.
Optional<?>	ResultQuery.fetchOptional(String fieldName) Execute the query and return at most one resulting value for a field name from the generated result.
Optional<Record>	DSLContext.fetchOptional(String sql) Execute a new query holding plain SQL.
<T> Optional<T>	ResultQuery.fetchOptional(String fieldName, Class<? extends T> type) Execute the query and return at most one resulting value for a field name from the generated result.
<U> Optional<U>	ResultQuery.fetchOptional(String fieldName, Converter<?,? extends U> converter) Execute the query and return at most one resulting value for a field name from the generated result.
Optional<Record>	DSLContext.fetchOptional(String sql, Object... bindings) Execute a new query holding plain SQL.
Optional<Record>	DSLContext.fetchOptional(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<R extends Record> Optional<R>	DSLContext.fetchOptional(Table<R> table) Execute and return zero or one record for SELECT * FROM [table].
<R extends Record> Optional<R>	DSLContext.fetchOptional(Table<R> table, Condition condition) Execute and return zero or one record for SELECT * FROM [table] WHERE [condition] .
Optional<Object[]>	ResultQuery.fetchOptionalArray() Execute the query and return at most one resulting record as an array.
<E> Optional<E>	ResultQuery.fetchOptionalInto(Class<? extends E> type) Map resulting records onto a custom type.
<E> Optional<E>	Cursor.fetchOptionalInto(Class<? extends E> type) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextOptionalInto(Class) instead.
<Z extends Record> Optional<Z>	ResultQuery.fetchOptionalInto(Table<Z> table) Map resulting records onto a custom record.
<Z extends Record> Optional<Z>	Cursor.fetchOptionalInto(Table<Z> table) Deprecated. - 3.10 - [#6363] - Use Cursor.fetchNextOptionalInto(Table) instead.
Optional<Map<String,Object>>	ResultQuery.fetchOptionalMap() Execute the query and return at most one resulting record as a name/value map.
<T,R extends Record1<T>> Optional<T>	DSLContext.fetchOptionalValue(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a single value.
Optional<?>	DSLContext.fetchOptionalValue(ResultSet rs) Fetch a record from a JDBC ResultSet and return the only contained value.
<T> Optional<T>	DSLContext.fetchOptionalValue(ResultSet rs, Class<T> type) Fetch a record from a JDBC ResultSet and return the only contained value.
<T> Optional<T>	DSLContext.fetchOptionalValue(ResultSet rs, DataType<T> type) Fetch a record from a JDBC ResultSet and return the only contained value.
<T> Optional<T>	DSLContext.fetchOptionalValue(ResultSet rs, Field<T> field) Fetch a record from a JDBC ResultSet and return the only contained value.
Optional<?>	DSLContext.fetchOptionalValue(SQL sql) Execute a new query holding plain SQL.
Optional<?>	DSLContext.fetchOptionalValue(String sql) Execute a new query holding plain SQL.
Optional<?>	DSLContext.fetchOptionalValue(String sql, Object... bindings) Execute a new query holding plain SQL.
Optional<?>	DSLContext.fetchOptionalValue(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<T> Optional<T>	DSLContext.fetchOptionalValue(TableField<?,T> field) Execute a ResultQuery in the context of this DSLContext and return a single value.
<O extends UpdatableRecord<O>> O	TableRecord.fetchParent(ForeignKey<R,O> key) Fetch a parent record of this record, given a foreign key.
O	ForeignKey.fetchParent(R record) Fetch a parent record of a given record through this foreign key This returns a parent record referenced by a given record through this foreign key.
Result<O>	ForeignKey.fetchParents(Collection<? extends R> records) Fetch parent records of a given set of record through this foreign key This returns parent records referenced by any record in a given set of records through this foreign key.
<O extends UpdatableRecord<O>> Result<O>	Result.fetchParents(ForeignKey<R,O> key) Fetch parent records of this record, given a foreign key.
Result<O>	ForeignKey.fetchParents(R... records) Fetch parent records of a given set of record through this foreign key This returns parent records referenced by any record in a given set of records through this foreign key.
ResultSet	ResultQuery.fetchResultSet() Execute the query and return the generated result as a JDBC ResultSet.
<T> Set<T>	ResultQuery.fetchSet(Field<?> field, Class<? extends T> type) Execute the query and return all values for a field from the generated result.
<T> Set<T>	ResultQuery.fetchSet(Field<T> field) Execute the query and return all values for a field from the generated result.
<T,U> Set<U>	ResultQuery.fetchSet(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return all values for a field from the generated result.
Set<?>	ResultQuery.fetchSet(int fieldIndex) Execute the query and return all values for a field index from the generated result.
<T> Set<T>	ResultQuery.fetchSet(int fieldIndex, Class<? extends T> type) Execute the query and return all values for a field index from the generated result.
<U> Set<U>	ResultQuery.fetchSet(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return all values for a field index from the generated result.
Set<?>	ResultQuery.fetchSet(Name fieldName) Execute the query and return all values for a field name from the generated result.
<T> Set<T>	ResultQuery.fetchSet(Name fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> Set<U>	ResultQuery.fetchSet(Name fieldName, Converter<?,? extends U> converter) Execute the query and return all values for a field name from the generated result.
<E> Set<E>	ResultQuery.fetchSet(RecordMapper<? super R,E> mapper) Fetch results into a custom mapper callback.
Set<?>	ResultQuery.fetchSet(String fieldName) Execute the query and return all values for a field name from the generated result.
<T> Set<T>	ResultQuery.fetchSet(String fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> Set<U>	ResultQuery.fetchSet(String fieldName, Converter<?,? extends U> converter) Execute the query and return all values for a field name from the generated result.
R	ResultQuery.fetchSingle() Execute the query and return exactly one resulting record.
<T> T	ResultQuery.fetchSingle(Field<?> field, Class<? extends T> type) Execute the query and return exactly one resulting value for a field from the generated result.
<T> T	ResultQuery.fetchSingle(Field<T> field) Execute the query and return exactly one resulting value for a field from the generated result.
<T,U> U	ResultQuery.fetchSingle(Field<T> field, Converter<? super T,? extends U> converter) Execute the query and return exactly one resulting value for a field from the generated result.
Object	ResultQuery.fetchSingle(int fieldIndex) Execute the query and return exactly one resulting value for a field index from the generated result.
<T> T	ResultQuery.fetchSingle(int fieldIndex, Class<? extends T> type) Execute the query and return exactly one resulting value for a field index from the generated result.
<U> U	ResultQuery.fetchSingle(int fieldIndex, Converter<?,? extends U> converter) Execute the query and return exactly one resulting value for a field index from the generated result.
Object	ResultQuery.fetchSingle(Name fieldName) Execute the query and return exactly one resulting value for a field name from the generated result.
<T> T	ResultQuery.fetchSingle(Name fieldName, Class<? extends T> type) Execute the query and return exactly one resulting value for a field name from the generated result.
<U> U	ResultQuery.fetchSingle(Name fieldName, Converter<?,? extends U> converter) Execute the query and return exactly one resulting value for a field name from the generated result.
<E> E	ResultQuery.fetchSingle(RecordMapper<? super R,E> mapper) Execute the query and return exactly one resulting value into a custom mapper callback.
<R extends Record> R	DSLContext.fetchSingle(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a record.
Record	DSLContext.fetchSingle(ResultSet rs) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchSingle(ResultSet rs, Class<?>... types) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchSingle(ResultSet rs, DataType<?>... types) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchSingle(ResultSet rs, Field<?>... fields) Fetch a record from a JDBC ResultSet and transform it to a jOOQ Record.
Record	DSLContext.fetchSingle(SQL sql) Execute a new query holding plain SQL.
Object	ResultQuery.fetchSingle(String fieldName) Execute the query and return exactly one resulting value for a field name from the generated result.
Record	DSLContext.fetchSingle(String sql) Execute a new query holding plain SQL.
<T> T	ResultQuery.fetchSingle(String fieldName, Class<? extends T> type) Execute the query and return exactly one resulting value for a field name from the generated result.
<U> U	ResultQuery.fetchSingle(String fieldName, Converter<?,? extends U> converter) Execute the query and return exactly one resulting value for a field name from the generated result.
Record	DSLContext.fetchSingle(String sql, Object... bindings) Execute a new query holding plain SQL.
Record	DSLContext.fetchSingle(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<R extends Record> R	DSLContext.fetchSingle(Table<R> table) Execute and return exactly one record for SELECT * FROM [table].
<R extends Record> R	DSLContext.fetchSingle(Table<R> table, Condition condition) Execute and return exactly one record for SELECT * FROM [table] WHERE [condition] .
Object[]	ResultQuery.fetchSingleArray() Execute the query and return exactly one resulting record as an array You can access data like this query.fetchSingleArray()[fieldIndex]
<E> E	ResultQuery.fetchSingleInto(Class<? extends E> type) Map resulting records onto a custom type.
<Z extends Record> Z	ResultQuery.fetchSingleInto(Table<Z> table) Map resulting records onto a custom record.
Map<String,Object>	ResultQuery.fetchSingleMap() Execute the query and return exactly one resulting record as a name/value map.
Stream<R>	ResultQuery.fetchStream() Stream this query.
<R extends Record> Stream<R>	DSLContext.fetchStream(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a stream.
Stream<Record>	DSLContext.fetchStream(ResultSet rs) Wrap a JDBC ResultSet into a jOOQ Stream.
Stream<Record>	DSLContext.fetchStream(ResultSet rs, Class<?>... types) Wrap a JDBC ResultSet into a jOOQ Stream.
Stream<Record>	DSLContext.fetchStream(ResultSet rs, DataType<?>... types) Wrap a JDBC ResultSet into a jOOQ Stream.
Stream<Record>	DSLContext.fetchStream(ResultSet rs, Field<?>... fields) Wrap a JDBC ResultSet into a jOOQ Stream.
Stream<Record>	DSLContext.fetchStream(SQL sql) Execute a new query holding plain SQL and "lazily" return the generated result.
Stream<Record>	DSLContext.fetchStream(String sql) Execute a new query holding plain SQL and "lazily" return the generated result.
Stream<Record>	DSLContext.fetchStream(String sql, Object... bindings) Execute a new query holding plain SQL and "lazily" return the generated result.
Stream<Record>	DSLContext.fetchStream(String sql, QueryPart... parts) Execute a new query holding plain SQL and "lazily" return the generated result.
<R extends Record> Stream<R>	DSLContext.fetchStream(Table<R> table) Execute and return all records lazily for SELECT * FROM [table].
<R extends Record> Stream<R>	DSLContext.fetchStream(Table<R> table, Condition condition) Execute and return all records lazily for SELECT * FROM [table] WHERE [condition] .
<E> Stream<E>	ResultQuery.fetchStreamInto(Class<? extends E> type) Stream this query, mapping records into a custom type.
<Z extends Record> Stream<Z>	ResultQuery.fetchStreamInto(Table<Z> table) Stream this query, mapping records into a custom record.
<T> T	DSLContext.fetchValue(Field<T> field) Execute a ResultQuery in the context of this DSLContext and return a single value.
<T,R extends Record1<T>> T	DSLContext.fetchValue(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return a single value.
Object	DSLContext.fetchValue(ResultSet rs) Fetch a record from a JDBC ResultSet and return the only contained value.
<T> T	DSLContext.fetchValue(ResultSet rs, Class<T> type) Fetch a record from a JDBC ResultSet and return the only contained value.
<T> T	DSLContext.fetchValue(ResultSet rs, DataType<T> type) Fetch a record from a JDBC ResultSet and return the only contained value.
<T> T	DSLContext.fetchValue(ResultSet rs, Field<T> field) Fetch a record from a JDBC ResultSet and return the only contained value.
Object	DSLContext.fetchValue(SQL sql) Execute a new query holding plain SQL.
Object	DSLContext.fetchValue(String sql) Execute a new query holding plain SQL.
Object	DSLContext.fetchValue(String sql, Object... bindings) Execute a new query holding plain SQL.
Object	DSLContext.fetchValue(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<T> T	DSLContext.fetchValue(Table<? extends Record1<T>> table) Fetch a single value from a single column table.
<T> T	DSLContext.fetchValue(TableField<?,T> field) Execute a ResultQuery in the context of this DSLContext and return a single value.
<T,R extends Record1<T>> List<T>	DSLContext.fetchValues(ResultQuery<R> query) Execute a ResultQuery in the context of this DSLContext and return all values for the only column.
List<?>	DSLContext.fetchValues(ResultSet rs) Fetch a result from a JDBC ResultSet and return the only contained column's values.
<T> List<T>	DSLContext.fetchValues(ResultSet rs, Class<T> type) Fetch a result from a JDBC ResultSet and return the only contained column's values.
<T> List<T>	DSLContext.fetchValues(ResultSet rs, DataType<T> type) Fetch a result from a JDBC ResultSet and return the only contained column's values.
<T> List<T>	DSLContext.fetchValues(ResultSet rs, Field<T> field) Fetch a result from a JDBC ResultSet and return the only contained column's values.
List<?>	DSLContext.fetchValues(SQL sql) Execute a new query holding plain SQL.
List<?>	DSLContext.fetchValues(String sql) Execute a new query holding plain SQL.
List<?>	DSLContext.fetchValues(String sql, Object... bindings) Execute a new query holding plain SQL.
List<?>	DSLContext.fetchValues(String sql, QueryPart... parts) Execute a new query holding plain SQL.
<T> List<T>	DSLContext.fetchValues(Table<? extends Record1<T>> table) Fetch all values from a single column table.
<T> List<T>	DSLContext.fetchValues(TableField<?,T> field) Fetch all values in a given Table's TableField.
List<P>	DAO.findAll() Find all records of the underlying table.
P	DAO.findById(T id) Find a record of the underlying table by ID.
Catalog	Meta.getCatalog(Name name) Get a catalog object by name from the underlying meta data source, or null if no such object exists.
Catalog	Meta.getCatalog(String name) Get a catalog object by name from the underlying meta data source, or null if no such object exists.
List<Catalog>	Meta.getCatalogs() Get all catalog objects from the underlying meta data source.
List<UniqueKey<?>>	Meta.getPrimaryKeys() Get all primary keys from the underlying meta data source.
List<Schema>	Meta.getSchemas() Get all schema objects from the underlying meta data source.
List<Schema>	Meta.getSchemas(Name name) Get all schema objects by name from the underlying meta data source.
List<Schema>	Meta.getSchemas(String name) Get all schema objects by name from the underlying meta data source.
List<Sequence<?>>	Meta.getSequences() Get all sequence objects from the underlying meta data source.
List<Sequence<?>>	Meta.getSequences(Name name) Get all sequence objects by name from the underlying meta data source.
List<Sequence<?>>	Meta.getSequences(String name) Get all sequence objects by name from the underlying meta data source.
List<Table<?>>	Meta.getTables() Get all table objects from the underlying meta data source.
List<Table<?>>	Meta.getTables(Name name) Get all table objects by name from the underlying meta data source.
List<Table<?>>	Meta.getTables(String name) Get all table objects by name from the underlying meta data source.
boolean	Cursor.hasNext() Check whether this cursor has a next record.
int	UpdatableRecord.insert() Store this record back to the database using an INSERT statement.
int	TableRecord.insert() Store this record to the database using an INSERT statement.
int	UpdatableRecord.insert(Collection<? extends Field<?>> fields) Store parts of this record to the database using an INSERT statement.
int	TableRecord.insert(Collection<? extends Field<?>> fields) Store parts of this record to the database using an INSERT statement.
void	DAO.insert(Collection<P> objects) Performs a batch INSERT statement for a given set of POJOs
int	UpdatableRecord.insert(Field<?>... fields) Store parts of this record to the database using an INSERT statement.
int	TableRecord.insert(Field<?>... fields) Store parts of this record to the database using an INSERT statement.
void	DAO.insert(P... objects) Performs a batch INSERT statement for a given set of POJOs
void	DAO.insert(P object) Performs an INSERT statement for a given POJO
Iterator<R>	ResultQuery.iterator() Execute the query using ResultQuery.fetch() and return the generated result as an Iterator.
BigInteger	DSLContext.lastID() Retrieve the last inserted ID.
BigInteger	DSLContext.nextval(Name sequence) Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.
<T extends Number> T	DSLContext.nextval(Sequence<T> sequence) Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.
BigInteger	DSLContext.nextval(String sequence) Convenience method to fetch the NEXTVAL for a sequence directly from this DSLContext's underlying JDBC Connection.
TableOnConditionStep<R>	TableOnStep.onKey() Join the table on a non-ambiguous foreign key relationship between the two joined tables.
SelectJoinStep<R>	SelectOnStep.onKey() Join the previous table on a non-ambiguous foreign key relationship between the two joined tables.
TableOnConditionStep<R>	TableOnStep.onKey(TableField<?,?>... keyFields) Join the table on a non-ambiguous foreign key relationship between the two joined tables.
SelectJoinStep<R>	SelectOnStep.onKey(TableField<?,?>... keyFields) Join the previous table on a non-ambiguous foreign key relationship between the two joined tables.
void	UpdatableRecord.refresh() Refresh this record from the database.
void	UpdatableRecord.refresh(Collection<? extends Field<?>> fields) Refresh parts of this record from the database.
void	UpdatableRecord.refresh(Field<?>... fields) Refresh parts of this record from the database.
void	ConnectionProvider.release(Connection connection) Release a connection to the connection lifecycle handler.
void	TransactionProvider.rollback(TransactionContext ctx) Rollback a transaction.
int	UpdatableRecord.store() Store this record back to the database.
int	UpdatableRecord.store(Collection<? extends Field<?>> fields) Store parts of this record to the database.
int	UpdatableRecord.store(Field<?>... fields) Store parts of this record to the database.
Stream<R>	ResultQuery.stream() Stream this query.
Stream<R>	Cursor.stream() Turn this Cursor into a Stream.
int	UpdatableRecord.update() Store this record back to the database using an UPDATE statement.
int	UpdatableRecord.update(Collection<? extends Field<?>> fields) Store parts of this record to the database using an UPDATE statement.
void	DAO.update(Collection<P> objects) Performs a batch UPDATE statement for a given set of POJOs
int	UpdatableRecord.update(Field<?>... fields) Store parts of this record to the database using an UPDATE statement.
void	DAO.update(P... objects) Performs a batch UPDATE statement for a given set of POJOs
void	DAO.update(P object) Performs an UPDATE statement for a given POJO
C	Context.visit(QueryPart part) Visit a QueryPart in the current Context.

Uses of DataAccessException in org.jooq.exception

Subclasses of DataAccessException in org.jooq.exception

Modifier and Type	Class and Description
class	ConfigurationException The Configuration was set up in a way that does not allow for a particular operation.
class	DataChangedException An error occurred while storing a record whose underlying data had already been changed
class	DataTypeException An error occurred while handling data types.
class	DetachedException An operation was invoked on a detached object (Query, QueryPart, or UpdatableRecord).
class	InvalidResultException An unexpected result was encountered after executing a Query.
class	IOException The jOOQ IOException is a wrapper for a IOException.
class	LoaderConfigurationException The LoaderConfigurationException indicates that a Loader was executed with an illegal execution configuration.
class	MappingException An error occurred while fetching data into a user defined Java object with any of these methods: ResultQuery.fetchInto(Class) Cursor.fetchInto(Class) Result.into(Class) Record.into(Class) ... or when copying data into a Record with any of these methods DSLContext.newRecord(org.jooq.Table, Object) Record.from(Object)
class	MockFileDatabaseException An unexpected result can be encountered while loading a file-based MockDataProvider.
class	NoDataFoundException No rows were returned from a ResultQuery, when exactly one row was expected.
class	TooManyRowsException Too many rows (more than 1) were returned from a ResultQuery.

Uses of DataAccessException in org.jooq.impl

Subclasses of DataAccessException in org.jooq.impl

Modifier and Type	Class and Description
class	ParserException An exception that arises while parsing SQL through DSLContext.parser().

Methods in org.jooq.impl that throw DataAccessException

Modifier and Type	Method and Description
void	DefaultConnectionProvider.commit() Convenience method to access Connection.commit().
BigInteger	DefaultDSLContext.currval(Name sequence)
boolean	DefaultDSLContext.fetchExists(Select<?> query)
boolean	DefaultDSLContext.fetchExists(Table<?> table)
boolean	DefaultDSLContext.fetchExists(Table<?> table, Condition condition)
<T> List<T>	DefaultDSLContext.fetchValues(Table<? extends Record1<T>> table)
boolean	DefaultConnectionProvider.getAutoCommit() Convenience method to access Connection.getAutoCommit().
int	DefaultConnectionProvider.getHoldability() Convenience method to access Connection.getHoldability().
int	DefaultConnectionProvider.getTransactionIsolation() Convenience method to access Connection.getTransactionIsolation().
boolean	DefaultConnectionProvider.isReadOnly() Convenience method to access Connection.isReadOnly().
void	DefaultConnectionProvider.releaseSavepoint(Savepoint savepoint) Convenience method to access Connection.releaseSavepoint(Savepoint).
void	DefaultConnectionProvider.rollback() Convenience method to access Connection.rollback().
void	DefaultConnectionProvider.rollback(Savepoint savepoint) Convenience method to access Connection.rollback(Savepoint).
void	DefaultConnectionProvider.setAutoCommit(boolean autoCommit) Convenience method to access Connection.setAutoCommit(boolean).
void	DefaultConnectionProvider.setHoldability(int holdability) Convenience method to access Connection.setHoldability(int).
void	DefaultConnectionProvider.setReadOnly(boolean readOnly) Convenience method to access Connection.setReadOnly(boolean).
Savepoint	DefaultConnectionProvider.setSavepoint() Convenience method to access Connection.setSavepoint().
Savepoint	DefaultConnectionProvider.setSavepoint(String name) Convenience method to access Connection.setSavepoint(String).
void	DefaultConnectionProvider.setTransactionIsolation(int level) Convenience method to access Connection.setTransactionIsolation(int).