org.jooq

Interface ResultQuery<R extends Record>

All Superinterfaces:

Adapter, Attachable, Query, QueryPart, Serializable

All Known Subinterfaces:

Select<R>, SelectConditionStep, SelectConnectByConditionStep, SelectConnectByStep, SelectFinalStep, SelectForUpdateOfStep, SelectForUpdateStep, SelectForUpdateWaitStep, SelectFromStep, SelectGroupByStep, SelectHavingConditionStep, SelectHavingStep, SelectJoinStep, SelectLimitStep, SelectOffsetStep, SelectOnConditionStep, SelectOptionalOnStep, SelectOrderByStep, SelectQuery, SelectSelectStep, SelectStartWithStep, SelectWhereStep, SimpleSelectConditionStep<R>, SimpleSelectFinalStep<R>, SimpleSelectForUpdateOfStep<R>, SimpleSelectForUpdateStep<R>, SimpleSelectForUpdateWaitStep<R>, SimpleSelectLimitStep<R>, SimpleSelectOffsetStep<R>, SimpleSelectOrderByStep<R>, SimpleSelectQuery<R>, SimpleSelectWhereStep<R>

public interface ResultQuery<R extends Record>
extends Query

A query that can return results. Mostly, this is a Select query used for a SELECT statement.

However, some RDBMS also allow for other constructs, such as Postgres' FETCH ALL IN {cursor-name}. The easiest way to execute such a query is by using

 Factory create = new PostgresFactory(connection);
 Result<Record> result = create.fetch("FETCH ALL IN \"<unnamed cursor 1>\"");
 

Another example (for SQLite):

 Result<Record> result = create.fetch("pragma table_info('my_table')");
 

Author:

Lukas Eder

Method Summary

Methods

Modifier and Type	Method and Description
ResultQuery<R>	bind(int index, Object value) Bind a new value to an indexed parameter [#1886] If the bind value at index is inlined ( Param.isInline()) or if this query was created with StatementType.STATIC_STATEMENT and there is an underlying PreparedStatement kept open because of Query.keepStatement(boolean), the underlying PreparedStatement will be closed automatically in order for new bind values to have an effect.
ResultQuery<R>	bind(String param, Object value) Bind a new value to a named parameter [#1886] If the bind value with name param is inlined ( Param.isInline()) or if this query was created with StatementType.STATIC_STATEMENT and there is an underlying PreparedStatement kept open because of Query.keepStatement(boolean), the underlying PreparedStatement will be closed automatically in order for new bind values to have an effect.
Result<R>	fetch() Execute the query and return the generated result This is the same as calling Query.execute() and then getResult() The result and its contained records are attached to the original Configuration by default.
<T> List<T>	fetch(Field<?> field, Class<? extends T> type) Execute the query and return all values for a field from the generated result.
<T> List<T>	fetch(Field<T> field) Execute the query and return all values for a field from the generated result.
<T,U> List<U>	fetch(Field<T> field, Converter<? super T,U> converter) Execute the query and return all values for a field from the generated result.
List<?>	fetch(int fieldIndex) Execute the query and return all values for a field index from the generated result.
<T> List<T>	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>	fetch(int fieldIndex, Converter<?,U> converter) Execute the query and return all values for a field index from the generated result.
<E> List<E>	fetch(RecordMapper<? super R,E> mapper) Fetch results into a custom mapper callback
List<?>	fetch(String fieldName) Execute the query and return all values for a field name from the generated result.
<T> List<T>	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>	fetch(String fieldName, Converter<?,U> converter) Execute the query and return all values for a field name from the generated result.
R	fetchAny() Execute the query and return at most one resulting record.
<T> T[]	fetchArray(Field<?> field, Class<? extends T> type) Execute the query and return all values for a field from the generated result.
<T> T[]	fetchArray(Field<T> field) Execute the query and return all values for a field from the generated result.
<T,U> U[]	fetchArray(Field<T> field, Converter<? super T,U> converter) Execute the query and return all values for a field from the generated result.
Object[]	fetchArray(int fieldIndex) Execute the query and return all values for a field index from the generated result.
<T> T[]	fetchArray(int fieldIndex, Class<? extends T> type) Execute the query and return all values for a field index from the generated result.
<U> U[]	fetchArray(int fieldIndex, Converter<?,U> converter) Execute the query and return all values for a field index from the generated result.
Object[]	fetchArray(String fieldName) Execute the query and return all values for a field name from the generated result.
<T> T[]	fetchArray(String fieldName, Class<? extends T> type) Execute the query and return all values for a field name from the generated result.
<U> U[]	fetchArray(String fieldName, Converter<?,U> converter) Execute the query and return all values for a field name from the generated result.
Object[][]	fetchArrays() Execute the query and return the generated result as an Object matrix You can access data like this query.fetchArray()[recordIndex][fieldIndex]
Map<Record,Result<R>>	fetchGroups(Field<?>[] keys) Execute the query and return a Map with the result grouped by the given keys.
<E> Map<Record,List<E>>	fetchGroups(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.
<K> Map<K,Result<R>>	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>>	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>>	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 fetchMap(Field, Field), this method allows for non-unique keys in the result set.
<E> List<E>	fetchInto(Class<? extends E> type) Map resulting records onto a custom type.
<H extends RecordHandler<R>> H	fetchInto(H handler) Fetch results into a custom handler callback The resulting records are attached to the original Configuration by default.
<Z extends Record> Result<Z>	fetchInto(Table<Z> table) Map resulting records onto a custom record.
FutureResult<R>	fetchLater() Fetch results asynchronously.
FutureResult<R>	fetchLater(ExecutorService executor) Fetch results asynchronously.
Cursor<R>	fetchLazy() Execute the query and "lazily" return the generated result The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet.
Cursor<R>	fetchLazy(int fetchSize) Execute the query and "lazily" return the generated result The returned Cursor holds a reference to the executed PreparedStatement and the associated ResultSet.
List<Result<Record>>	fetchMany() Execute a query, possibly returning several result sets.
Map<Record,R>	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>	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.
<K> Map<K,R>	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>	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>	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.
List<Map<String,Object>>	fetchMaps() Execute the query and return the generated result as a list of name/value maps.
R	fetchOne() Execute the query and return at most one resulting record.
<T> T	fetchOne(Field<?> field, Class<? extends T> type) Execute the query and return return at most one resulting value for a field from the generated result.
<T> T	fetchOne(Field<T> field) Execute the query and return return at most one resulting value for a field from the generated result.
<T,U> U	fetchOne(Field<T> field, Converter<? super T,U> converter) Execute the query and return return at most one resulting value for a field from the generated result.
Object	fetchOne(int fieldIndex) Execute the query and return return at most one resulting value for a field index from the generated result.
<T> T	fetchOne(int fieldIndex, Class<? extends T> type) Execute the query and return return at most one resulting value for a field index from the generated result.
<U> U	fetchOne(int fieldIndex, Converter<?,U> converter) Execute the query and return return at most one resulting value for a field index from the generated result.
Object	fetchOne(String fieldName) Execute the query and return return at most one resulting value for a field name from the generated result.
<T> T	fetchOne(String fieldName, Class<? extends T> type) Execute the query and return return at most one resulting value for a field name from the generated result.
<U> U	fetchOne(String fieldName, Converter<?,U> converter) Execute the query and return return at most one resulting value for a field name from the generated result.
Object[]	fetchOneArray() Execute the query and return at most one resulting record as an array You can access data like this query.fetchOneArray()[fieldIndex]
Map<String,Object>	fetchOneMap() Execute the query and return at most one resulting record as a name/value map.
ResultSet	fetchResultSet() Execute the query and return the generated result as a JDBC ResultSet This will return the ResultSet returned by the JDBC driver, leaving it untouched.
Class<? extends R>	getRecordType() The record type produced by this query
Result<R>	getResult() Return the result generated by a previous call to execute();
ResultQuery<R>	keepStatement(boolean keepStatement) Keep the query's underlying statement open after execution This indicates to jOOQ that the query's underlying Statement or PreparedStatement should be kept open after execution.
ResultQuery<R>	maxRows(int rows) Specify the maximum number of rows returned by the underlying Statement This is not the same as setting a LIMIT ..
ResultQuery<R>	queryTimeout(int timeout) Specify the query timeout for the underlying JDBC Statement

Methods inherited from interface org.jooq.Query

cancel, close, execute, getBindValues, getParam, getParams, getSQL, getSQL, isExecutable

Methods inherited from interface org.jooq.QueryPart

attach

Methods inherited from interface org.jooq.Adapter

internalAPI

Method Detail

getResult

Result<R> getResult()

Return the result generated by a previous call to execute();

Returns:

The result or null if no call to execute() was done previously.

fetch

Result<R> fetch()
                               throws DataAccessException

Execute the query and return the generated result

This is the same as calling Query.execute() and then getResult()

The result and its contained records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The result.

Throws:

DataAccessException - if something went wrong executing the query

fetchResultSet

ResultSet fetchResultSet()
                         throws DataAccessException

Execute the query and return the generated result as a JDBC ResultSet

This will return the ResultSet returned by the JDBC driver, leaving it untouched. Use this method when you want to use jOOQ for query execution, but not for result fetching.

The returned ResultSet can be used with FactoryOperations.fetch(ResultSet)

Returns:

The result.

Throws:

DataAccessException - if something went wrong executing the query

fetchLazy

Cursor<R> fetchLazy()
                                   throws DataAccessException

Execute the query and "lazily" return the generated result

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

Depending on your JDBC driver's default behaviour, this may load the whole database result into the driver's memory. In order to indicate to the driver that you may not want to fetch all records at once, use fetchLazy(int)

Client code is responsible for closing the cursor after use.

Returns:

The resulting cursor.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

fetchLazy(int)

fetchLazy

Cursor<R> fetchLazy(int fetchSize)
                                   throws DataAccessException

Execute the query and "lazily" return the generated result

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

Depending on your JDBC driver's behaviour, this will load only fetchSize records from the database into memory at once. For more details, see also Statement.setFetchSize(int)

Client code is responsible for closing the cursor after use.

Returns:

The resulting cursor.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

fetchLazy(), Statement.setFetchSize(int)

fetchMany

List<Result<Record>> fetchMany()
                               throws DataAccessException

Execute a query, possibly returning several result sets.

Example (Sybase ASE):

 String sql = "sp_help 'my_table'";

The result and its contained records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The resulting records

Throws:

DataAccessException - if something went wrong executing the query

fetch

<T> List<T> fetch(Field<T> field)
              throws DataAccessException

Execute the query and return all values for a field from the generated result.

This is the same as calling fetch() and then Result.getValues(Field)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

fetch

<T> List<T> fetch(Field<?> field,
                Class<? extends T> type)
              throws DataAccessException

Execute the query and return all values for a field from the generated result.

This is the same as calling fetch() and then Result.getValues(Field, Class)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.getValue(Field, Class)

fetch

<T,U> List<U> fetch(Field<T> field,
                  Converter<? super T,U> converter)
              throws DataAccessException

Execute the query and return all values for a field from the generated result.

This is the same as calling fetch() and then Result.getValues(Field, Converter)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.getValue(Field, Converter)

fetch

List<?> fetch(int fieldIndex)
              throws DataAccessException

Execute the query and return all values for a field index from the generated result.

This is the same as calling fetch() and then Result.getValues(int)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

fetch

<T> List<T> fetch(int fieldIndex,
                Class<? extends T> type)
              throws DataAccessException

Execute the query and return all values for a field index from the generated result.

This is the same as calling fetch() and then Result.getValues(int, Class)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.getValue(int, Class)

fetch

<U> List<U> fetch(int fieldIndex,
                Converter<?,U> converter)
              throws DataAccessException

Execute the query and return all values for a field index from the generated result.

This is the same as calling fetch() and then Result.getValues(int, Converter)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.getValue(int, Converter)

fetch

List<?> fetch(String fieldName)
              throws DataAccessException

Execute the query and return all values for a field name from the generated result.

This is the same as calling fetch() and then Result.getValues(String)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

fetch

<T> List<T> fetch(String fieldName,
                Class<? extends T> type)
              throws DataAccessException

Execute the query and return all values for a field name from the generated result.

This is the same as calling fetch() and then Result.getValues(String, Class)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.getValue(String, Class)

fetch

<U> List<U> fetch(String fieldName,
                Converter<?,U> converter)
              throws DataAccessException

Execute the query and return all values for a field name from the generated result.

This is the same as calling fetch() and then Result.getValues(String, Converter)

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.getValue(String, Converter)

fetchOne

<T> T fetchOne(Field<T> field)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field from the generated result.

This is the same as calling fetchOne() and then Record.getValue(Field)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

<T> T fetchOne(Field<?> field,
             Class<? extends T> type)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field from the generated result.

This is the same as calling fetchOne() and then Record.getValue(Field, Class)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

<T,U> U fetchOne(Field<T> field,
               Converter<? super T,U> converter)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field from the generated result.

This is the same as calling fetchOne() and then Record.getValue(Field, Converter)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

Object fetchOne(int fieldIndex)
                throws DataAccessException

Execute the query and return return at most one resulting value for a field index from the generated result.

This is the same as calling fetchOne() and then Record.getValue(int)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

<T> T fetchOne(int fieldIndex,
             Class<? extends T> type)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field index from the generated result.

This is the same as calling fetchOne() and then Record.getValue(int, Class)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

<U> U fetchOne(int fieldIndex,
             Converter<?,U> converter)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field index from the generated result.

This is the same as calling fetchOne() and then Record.getValue(int, Converter)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

Object fetchOne(String fieldName)
                throws DataAccessException

Execute the query and return return at most one resulting value for a field name from the generated result.

This is the same as calling fetchOne() and then Record.getValue(int)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

<T> T fetchOne(String fieldName,
             Class<? extends T> type)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field name from the generated result.

This is the same as calling fetchOne() and then Record.getValue(String, Class)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

<U> U fetchOne(String fieldName,
             Converter<?,U> converter)
           throws DataAccessException

Execute the query and return return at most one resulting value for a field name from the generated result.

This is the same as calling fetchOne() and then Record.getValue(String, Converter)

Returns:

The resulting value or null if the query returned no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchOne

R fetchOne()
                          throws DataAccessException

Execute the query and return at most one resulting record.

The resulting record is attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The resulting record or null if the query returns no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchAny

R fetchAny()
                          throws DataAccessException

Execute the query and return at most one resulting record.

The resulting record is attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

The first resulting record or null if the query returns no records.

Throws:

DataAccessException - if something went wrong executing the query

fetchMaps

List<Map<String,Object>> fetchMaps()
                                   throws DataAccessException

Execute the query and return the generated result as a list of name/value maps.

Returns:

The result.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the key field returned two or more equal values from the result set.

See Also:

Result.intoMaps(), Record.intoMap()

fetchOneMap

Map<String,Object> fetchOneMap()
                               throws DataAccessException

Execute the query and return at most one resulting record as a name/value map.

Returns:

The resulting record or null if the query returns no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

See Also:

Result.intoMaps(), Record.intoMap()

fetchMap

<K> Map<K,R> fetchMap(Field<K> key)
                                 throws DataAccessException

Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.

An exception is thrown, if the key turns out to be non-unique in the result set. Use fetchGroups(Field) instead, if your keys are non-unique

The resulting records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

K - The key's generic field type

Parameters:

key - The key field. Client code must assure that this field is unique in the result set.

Returns:

A Map containing the results

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the key field returned two or more equal values from the result set.

See Also:

Result.intoMap(Field)

fetchMap

<K,V> Map<K,V> fetchMap(Field<K> key,
                      Field<V> value)
                  throws DataAccessException

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. Use fetchGroups(Field, Field) instead, if your keys are non-unique

Type Parameters:

K - The key's generic field type

V - The value's generic field type

Parameters:

key - The key field. Client code must assure that this field is unique in the result set.

value - The value field

Returns:

A Map containing the results

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the key field returned two or more equal values from the result set.

See Also:

Result.intoMap(Field, Field)

fetchMap

Map<Record,R> fetchMap(Field<?>[] keys)
                                      throws DataAccessException

Execute the query and return a Map with keys as a map key and the corresponding record as value.

An exception is thrown, if the keys turn out to be non-unique in the result set. Use fetchGroups(Field[]) instead, if your keys are non-unique.

Parameters:

keys - The keys. Client code must assure that keys are unique in the result set.

Returns:

A Map containing the results.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the key list is non-unique in the result set.

See Also:

Result.intoMap(Field[])

fetchMap

<E> Map<List<?>,E> fetchMap(Field<?>[] keys,
                          Class<? extends E> type)
                        throws MappingException

Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.

An InvalidResultException is thrown, if the keys are non-unique in the result set. Use fetchGroups(Field[], Class) instead, if your keys are non-unique.

Parameters:

keys - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.

Returns:

A Map containing the results.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the keys are non-unique in the result set.

MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

See Also:

Result.intoMap(Field[], Class)

fetchMap

<K,E> Map<K,E> fetchMap(Field<K> key,
                      Class<? extends E> type)
                  throws DataAccessException

Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.

An exception is thrown, if the key turn out to be non-unique in the result set. Use fetchGroups(Field, Class) instead, if your key is non-unique.

Parameters:

key - The key. Client code must assure that key is unique in the result set.

Returns:

A Map containing the result.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the key is non-unique in the result set.

See Also:

Result.intoMap(Field, Class)

fetchGroups

<K> Map<K,Result<R>> fetchGroups(Field<K> key)
                                            throws DataAccessException

Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.

Unlike fetchMap(Field), this method allows for non-unique keys in the result set.

The resulting records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

K - The key's generic field type

Parameters:

key - The key field.

Returns:

A Map containing the results

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoGroups(Field)

fetchGroups

<K,V> Map<K,List<V>> fetchGroups(Field<K> key,
                               Field<V> value)
                           throws DataAccessException

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 fetchMap(Field, Field), this method allows for non-unique keys in the result set.

Type Parameters:

K - The key's generic field type

V - The value's generic field type

Parameters:

key - The key field.

value - The value field

Returns:

A Map containing the results

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoGroups(Field, Field)

fetchGroups

Map<Record,Result<R>> fetchGroups(Field<?>[] keys)
                                                 throws DataAccessException

Execute the query and return a Map with the result grouped by the given keys.

Unlike fetchMap(Field[]), this method allows for non-unique keys in the result set.

Parameters:

keys - The keys used for result grouping.

Returns:

A Map containing grouped results

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoGroups(Field[])

fetchGroups

<E> Map<Record,List<E>> fetchGroups(Field<?>[] keys,
                                  Class<? extends E> type)
                                throws MappingException

Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.

Unlike fetchMap(Field[], Class), this method allows for non-unique keys in the result set.

Parameters:

keys - The keys. If this is null or an empty array, the resulting map will contain at most one entry.

Returns:

A Map containing grouped results

Throws:

DataAccessException - if something went wrong executing the query

MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

See Also:

Result.intoGroups(Field[], Class)

fetchGroups

<K,E> Map<K,List<E>> fetchGroups(Field<K> key,
                               Class<? extends E> type)
                           throws DataAccessException,
                                  MappingException

Return a Map with results grouped by the given key and mapped into the given entity type.

Type Parameters:

K - The key's generic field type

E - The generic entity type.

Parameters:

key - The key field.

type - The entity type.

Throws:

DataAccessException - if something went wrong executing the query

MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

See Also:

Result.intoGroups(Field, Class)

fetchArrays

Object[][] fetchArrays()
                       throws DataAccessException

Execute the query and return the generated result as an Object matrix

You can access data like this

query.fetchArray()[recordIndex][fieldIndex]

Returns:

The result.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray()

fetchArray

Object[] fetchArray(int fieldIndex)
                    throws DataAccessException

Execute the query and return all values for a field index from the generated result.

You can access data like this

query.fetchArray(fieldIndex)[recordIndex]

Returns:

The resulting values. This may be an array type more concrete than Object[], depending on whether jOOQ has any knowledge about fieldIndex's actual type.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(int)

fetchArray

<T> T[] fetchArray(int fieldIndex,
                 Class<? extends T> type)
               throws DataAccessException

Execute the query and return all values for a field index from the generated result.

You can access data like this

query.fetchArray(fieldIndex)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(int, Class)

fetchArray

<U> U[] fetchArray(int fieldIndex,
                 Converter<?,U> converter)
               throws DataAccessException

Execute the query and return all values for a field index from the generated result.

You can access data like this

query.fetchArray(fieldIndex)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(int, Converter)

fetchArray

Object[] fetchArray(String fieldName)
                    throws DataAccessException

Execute the query and return all values for a field name from the generated result.

You can access data like this

query.fetchArray(fieldName)[recordIndex]

Returns:

The resulting values. This may be an array type more concrete than Object[], depending on whether jOOQ has any knowledge about fieldName's actual type.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(String)

fetchArray

<T> T[] fetchArray(String fieldName,
                 Class<? extends T> type)
               throws DataAccessException

Execute the query and return all values for a field name from the generated result.

You can access data like this

query.fetchArray(fieldName)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(String, Converter)

fetchArray

<U> U[] fetchArray(String fieldName,
                 Converter<?,U> converter)
               throws DataAccessException

Execute the query and return all values for a field name from the generated result.

You can access data like this

query.fetchArray(fieldName)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(String, Class)

fetchArray

<T> T[] fetchArray(Field<T> field)
               throws DataAccessException

Execute the query and return all values for a field from the generated result.

You can access data like this

query.fetchArray(field)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(Field)

fetchArray

<T> T[] fetchArray(Field<?> field,
                 Class<? extends T> type)
               throws DataAccessException

Execute the query and return all values for a field from the generated result.

You can access data like this

query.fetchArray(field)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(Field, Class)

fetchArray

<T,U> U[] fetchArray(Field<T> field,
                   Converter<? super T,U> converter)
               throws DataAccessException

Execute the query and return all values for a field from the generated result.

You can access data like this

query.fetchArray(field)[recordIndex]

Returns:

The resulting values.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Result.intoArray(Field, Converter)

fetchOneArray

Object[] fetchOneArray()
                       throws DataAccessException

Execute the query and return at most one resulting record as an array

You can access data like this

query.fetchOneArray()[fieldIndex]

Returns:

The resulting record or null if the query returns no records.

Throws:

DataAccessException - if something went wrong executing the query

InvalidResultException - if the query returned more than one record

fetchInto

<E> List<E> fetchInto(Class<? extends E> type)
                  throws DataAccessException,
                         MappingException

Map resulting records onto a custom type.

This is the same as calling fetch().into(type). See Record.into(Class) for more details

Type Parameters:

E - The generic entity type.

Parameters:

type - The entity type.

Throws:

DataAccessException - if something went wrong executing the query

MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

See Also:

Record.into(Class), Result.into(Class)

fetchInto

<Z extends Record> Result<Z> fetchInto(Table<Z> table)
                                   throws DataAccessException

Map resulting records onto a custom record.

This is the same as calling fetch().into(table). See Record.into(Table) for more details

The result and its contained records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Type Parameters:

Z - The generic table record type.

Parameters:

table - The table type.

Throws:

DataAccessException - if something went wrong executing the query

See Also:

Record.into(Table), Result.into(Table)

fetchInto

<H extends RecordHandler<R>> H fetchInto(H handler)
                                  throws DataAccessException

Fetch results into a custom handler callback

The resulting records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

handler - The handler callback

Returns:

Convenience result, returning the parameter handler itself

Throws:

DataAccessException - if something went wrong executing the query

fetch

<E> List<E> fetch(RecordMapper<? super R,E> mapper)
              throws DataAccessException

Fetch results into a custom mapper callback

Parameters:

mapper - The mapper callback

Returns:

The custom mapped records

Throws:

DataAccessException - if something went wrong executing the query

fetchLater

FutureResult<R> fetchLater()
                                          throws DataAccessException

Fetch results asynchronously.

This method wraps fetching of records in a Future, such that you can access the actual records at a future instant. This is especially useful when

• You want to load heavy data in the background, for instance when the user logs in and accesses a pre-calculated dashboard screen, before they access the heavy data.
• You want to parallelise several independent OLAP queries before merging all data into a single report
• ...

This will internally create a "single thread executor", that is shut down at the end of the FutureResult's lifecycle. Use fetchLater(ExecutorService) instead, if you want control over your executing threads.

The result and its contained records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Returns:

A future result

Throws:

DataAccessException - if something went wrong executing the query

fetchLater

FutureResult<R> fetchLater(ExecutorService executor)
                                          throws DataAccessException

Fetch results asynchronously.

This method wraps fetching of records in a Future, such that you can access the actual records at a future instant. This is especially useful when

• You want to load heavy data in the background, for instance when the user logs in and accesses a pre-calculated dashboard screen, before they access the heavy data.
• You want to parallelise several independent OLAP queries before merging all data into a single report
• ...

Use this method rather than fetchLater(), in order to keep control over thread lifecycles, if you manage threads in a J2EE container or with Spring, for instance.

The result and its contained records are attached to the original Configuration by default. Use Settings.isAttachRecords() to override this behaviour.

Parameters:

executor - A custom executor

Returns:

A future result

Throws:

DataAccessException - if something went wrong executing the query

getRecordType

Class<? extends R> getRecordType()

The record type produced by this query

bind

ResultQuery<R> bind(String param,
                  Object value)
                                   throws IllegalArgumentException,
                                          DataTypeException

Bind a new value to a named parameter

[#1886] If the bind value with name param is inlined ( Param.isInline()) or if this query was created with StatementType.STATIC_STATEMENT and there is an underlying PreparedStatement kept open because of Query.keepStatement(boolean), the underlying PreparedStatement will be closed automatically in order for new bind values to have an effect.

Specified by:

bind in interface Query

Parameters:

param - The named parameter name. If this is a number, then this is the same as calling Query.bind(int, Object)

value - The new bind value.

Throws:

IllegalArgumentException - if there is no parameter by the given parameter name or index.

DataTypeException - if value cannot be converted into the parameter's data type

bind

ResultQuery<R> bind(int index,
                  Object value)
                                   throws IllegalArgumentException,
                                          DataTypeException

Bind a new value to an indexed parameter

[#1886] If the bind value at index is inlined ( Param.isInline()) or if this query was created with StatementType.STATIC_STATEMENT and there is an underlying PreparedStatement kept open because of Query.keepStatement(boolean), the underlying PreparedStatement will be closed automatically in order for new bind values to have an effect.

Specified by:

bind in interface Query

Parameters:

index - The parameter index, starting with 1

value - The new bind value.

Throws:

IllegalArgumentException - if there is no parameter by the given parameter index.

DataTypeException - if value cannot be converted into the parameter's data type

queryTimeout

ResultQuery<R> queryTimeout(int timeout)

Specify the query timeout for the underlying JDBC Statement

Specified by:

queryTimeout in interface Query

See Also:

Statement.setQueryTimeout(int)

keepStatement

ResultQuery<R> keepStatement(boolean keepStatement)

Keep the query's underlying statement open after execution

This indicates to jOOQ that the query's underlying Statement or PreparedStatement should be kept open after execution. If it is kept open, client code is responsible for properly closing it using Query.close()

Specified by:

keepStatement in interface Query

Parameters:

keepStatement - Whether to keep the underlying statement open

maxRows

ResultQuery<R> maxRows(int rows)

Specify the maximum number of rows returned by the underlying Statement

This is not the same as setting a LIMIT .. OFFSET clause onto the statement, where the result set is restricted within the database.

See Also:

Statement.setMaxRows(int)