org.jooq

Interface ResultQuery<R extends Record>

All Superinterfaces:

Attachable, Query, QueryPart, Serializable

All Known Subinterfaces:

Select<R>, SelectConditionStep<R>, SelectConnectByConditionStep<R>, SelectConnectByStep<R>, SelectFinalStep<R>, SelectForUpdateOfStep<R>, SelectForUpdateStep<R>, SelectForUpdateWaitStep<R>, SelectFromStep<R>, SelectGroupByStep<R>, SelectHavingConditionStep<R>, SelectHavingStep<R>, SelectJoinStep<R>, SelectLimitStep<R>, SelectOffsetStep<R>, SelectOnConditionStep<R>, SelectOptionalOnStep<R>, SelectOptionStep<R>, SelectOrderByStep<R>, SelectQuery<R>, SelectSeekLimitStep<R>, SelectSeekStep1<R,T1>, SelectSeekStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>, SelectSeekStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>, SelectSeekStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>, SelectSeekStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>, SelectSeekStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>, SelectSeekStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>, SelectSeekStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>, SelectSeekStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>, SelectSeekStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>, SelectSeekStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>, SelectSeekStep2<R,T1,T2>, SelectSeekStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>, SelectSeekStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>, SelectSeekStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>, SelectSeekStep3<R,T1,T2,T3>, SelectSeekStep4<R,T1,T2,T3,T4>, SelectSeekStep5<R,T1,T2,T3,T4,T5>, SelectSeekStep6<R,T1,T2,T3,T4,T5,T6>, SelectSeekStep7<R,T1,T2,T3,T4,T5,T6,T7>, SelectSeekStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>, SelectSeekStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>, SelectSeekStepN<R>, SelectSelectStep<R>, SelectStartWithStep<R>, SelectWhereStep<R>, SelectWindowStep<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.

Lifecycle guarantees

Most methods in this type are based on fetch(), which completes the whole ConnectionProvider and ExecuteListener lifecycles, eagerly fetching all results into memory. Underlying JDBC ResultSets are always closed. Underlying JDBC PreparedStatements are closed, unless keepStatement(boolean) is set.

In order to keep open ResultSets and fetch records lazily, use fetchLazy() instead and then operate on Cursor.

Author:

Lukas Eder

Method Summary

Modifier and Type	Method and Description
ResultQuery<R>	bind(int index, Object value) Bind a new value to an indexed parameter.
ResultQuery<R>	bind(String param, Object value) Bind a new value to a named parameter.
Result<R>	fetch() Execute the query and return the generated result.
<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	fetchAny(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	fetchAny(Field<T> field) Execute the query and return return at most one resulting value for a field from the generated result.
<T,U> U	fetchAny(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	fetchAny(int fieldIndex) Execute the query and return return at most one resulting value for a field index from the generated result.
<T> T	fetchAny(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	fetchAny(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	fetchAny(String fieldName) Execute the query and return return at most one resulting value for a field name from the generated result.
<T> T	fetchAny(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	fetchAny(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[]	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	fetchAnyInto(Class<? extends E> type) Map resulting records onto a custom type.
<Z extends Record> Z	fetchAnyInto(Table<Z> table) Map resulting records onto a custom record.
Map<String,Object>	fetchAnyMap() Execute the query and return at most one resulting record as a name/value map.
<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.
<E> Map<Record,List<E>>	fetchGroups(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,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.
<K,E> Map<K,List<E>>	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.
<E> List<E>	fetchInto(Class<? extends E> type) Map resulting records onto a custom type.
<H extends RecordHandler<? super R>> H	fetchInto(H handler) Fetch results into a custom handler callback.
<Z extends Record> Result<Z>	fetchInto(Table<Z> table) Map resulting records onto a custom record.
FutureResult<R>	fetchLater() Deprecated. - 3.2.0 - [#2581] - This method will be removed in jOOQ 4.0
FutureResult<R>	fetchLater(ExecutorService executor) Deprecated. - 3.2.0 - [#2581] - This method will be removed in jOOQ 4.0
Cursor<R>	fetchLazy() Execute the query and "lazily" return the generated result.
Cursor<R>	fetchLazy(int fetchSize) Deprecated. - [#2811] - 3.3.0 - Use fetchSize(int) and fetchLazy() instead.
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.
<E> Map<List<?>,E>	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>	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.
<K,E> Map<K,E>	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.
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]
<E> E	fetchOneInto(Class<? extends E> type) Map resulting records onto a custom type.
<Z extends Record> Z	fetchOneInto(Table<Z> table) Map resulting records onto a custom record.
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.
ResultQuery<R>	fetchSize(int rows) Specify the fetch size of the underlying Statement.
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>	intern(Field<?>... fields) Specify a set of fields whose values should be interned.
ResultQuery<R>	intern(int... fieldIndexes) Specify a set of field indexes whose values should be interned.
ResultQuery<R>	intern(String... fieldNames) Specify a set of field names whose values should be interned.
ResultQuery<R>	keepStatement(boolean keepStatement) Keep the query's underlying statement open after execution.
ResultQuery<R>	maxRows(int rows) Specify the maximum number of rows returned by the underlying Statement.
ResultQuery<R>	queryTimeout(int timeout) Specify the query timeout for the underlying JDBC Statement.
ResultQuery<R>	resultSetConcurrency(int resultSetConcurrency) Specify the ResultSet concurrency of ResultSet objects created by jOOQ.
ResultQuery<R>	resultSetHoldability(int resultSetHoldability) Specify the ResultSet holdability of ResultSet objects created by jOOQ.
ResultQuery<R>	resultSetType(int resultSetType) Specify the ResultSet type of ResultSet objects created by jOOQ.

Methods inherited from interface org.jooq.Query

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

Methods inherited from interface org.jooq.QueryPart

equals, hashCode, toString

Methods inherited from interface org.jooq.Attachable

attach, detach

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.

Lifecycle guarantees

This method completes the whole ConnectionProvider and ExecuteListener lifecycles, eagerly fetching all results into memory. Underlying JDBC ResultSets are always closed. Underlying JDBC PreparedStatements are closed, unless keepStatement(boolean) is set.

In order to keep open ResultSets and fetch records lazily, use fetchLazy() instead and then operate on Cursor.

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 is the same as calling fetchLazy(). resultSet() and will return a ResultSet wrapping the JDBC driver's ResultSet. Closing this ResultSet may close the producing Statement or PreparedStatement, depending on your setting for keepStatement(boolean).

You can use this method when you want to use jOOQ for query execution, but not for result fetching. The returned ResultSet can also be used with DSLContext.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

@Deprecated
Cursor<R> fetchLazy(int fetchSize)
                          throws DataAccessException

Deprecated. - [#2811] - 3.3.0 - Use fetchSize(int) and fetchLazy() instead.

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,
               InvalidResultException

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,
               InvalidResultException

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,
                 InvalidResultException

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,
                InvalidResultException

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,
               InvalidResultException

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,
               InvalidResultException

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,
                InvalidResultException

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,
               InvalidResultException

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,
               InvalidResultException

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,
           InvalidResultException

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

fetchOneMap

Map<String,Object> fetchOneMap()
                        throws DataAccessException,
                               InvalidResultException

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

fetchOneArray

Object[] fetchOneArray()
                throws DataAccessException,
                       InvalidResultException

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

fetchOneInto

<E> E fetchOneInto(Class<? extends E> type)
            throws DataAccessException,
                   MappingException,
                   InvalidResultException

Map resulting records onto a custom type.

This is the same as calling

 E result = null;
 Record r = q.fetchOne();

 if (r != null)
     result = r.into(type);
 

. See Record.into(Class) for more details

Type Parameters:

E - The generic entity type.

Parameters:

type - The entity type.

Returns:

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

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

InvalidResultException - if the query returned more than one record

See Also:

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

fetchOneInto

<Z extends Record> Z fetchOneInto(Table<Z> table)
                           throws DataAccessException,
                                  InvalidResultException

Map resulting records onto a custom record.

This is the same as calling

 Z result = null;
 Record r = q.fetchOne();

 if (r != null)
     result = r.into(table);
 

. See Record.into(Table) for more details

The resulting record is 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.

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:

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

fetchAny

<T> T fetchAny(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

fetchAny

<T> T fetchAny(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

fetchAny

<T,U> U fetchAny(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

fetchAny

Object fetchAny(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

fetchAny

<T> T fetchAny(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

fetchAny

<U> U fetchAny(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

fetchAny

Object fetchAny(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

fetchAny

<T> T fetchAny(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

fetchAny

<U> U fetchAny(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

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

fetchAnyMap

Map<String,Object> fetchAnyMap()
                        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

See Also:

Result.intoMaps(), Record.intoMap()

fetchAnyArray

Object[] fetchAnyArray()
                throws DataAccessException

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

You can access data like this

query.fetchAnyArray()[fieldIndex]

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

fetchAnyInto

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

Map resulting records onto a custom type.

This is the same as calling

 E result = null;
 Record r = q.fetchAny();

 if (r != null)
     result = r.into(type);
 

. See Record.into(Class) for more details

Type Parameters:

E - The generic entity type.

Parameters:

type - The entity type.

Returns:

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

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), DefaultRecordMapper

fetchAnyInto

<Z extends Record> Z fetchAnyInto(Table<Z> table)
                           throws DataAccessException

Map resulting records onto a custom record.

This is the same as calling

 Z result = null;
 Record r = q.fetchOne();

 if (r != null)
     result = r.into(table);
 

. See Record.into(Table) for more details

The resulting record is 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.

Returns:

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

Throws:

DataAccessException - if something went wrong executing the query

See Also:

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

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

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.

type - The entity type.

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), DefaultRecordMapper

fetchMap

<E> Map<List<?>,E> fetchMap(Field<?>[] keys,
                            RecordMapper<? super R,E> mapper)
                     throws MappingException

Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.

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.

mapper - The mapper callback.

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), DefaultRecordMapper

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.

type - The entity type.

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)

fetchMap

<K,E> Map<K,E> fetchMap(Field<K> key,
                        RecordMapper<? super R,E> mapper)
                 throws DataAccessException

Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.

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.

mapper - The mapper callback.

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.

type - The entity type.

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), DefaultRecordMapper

fetchGroups

<E> Map<Record,List<E>> fetchGroups(Field<?>[] keys,
                                    RecordMapper<? super R,E> mapper)
                             throws MappingException

Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.

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.

mapper - The mapper callback.

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), DefaultRecordMapper

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), DefaultRecordMapper

fetchGroups

<K,E> Map<K,List<E>> fetchGroups(Field<K> key,
                                 RecordMapper<? super R,E> mapper)
                          throws DataAccessException,
                                 MappingException

Return a Map with results grouped by the given key and mapped by the given mapper.

Type Parameters:

K - The key's generic field type

E - The generic entity type.

Parameters:

key - The key field.

mapper - The mapper callback.

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), DefaultRecordMapper

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)

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), DefaultRecordMapper

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<? super 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

@Deprecated
FutureResult<R> fetchLater()
                                 throws DataAccessException

Deprecated. - 3.2.0 - [#2581] - This method will be removed in jOOQ 4.0

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

@Deprecated
FutureResult<R> fetchLater(ExecutorService executor)
                                 throws DataAccessException

Deprecated. - 3.2.0 - [#2581] - This method will be removed in jOOQ 4.0

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)

fetchSize

ResultQuery<R> fetchSize(int rows)

Specify the fetch size of the underlying Statement.

Regardless of this setting, fetchLazy() is the only way in jOOQ not to fetch all data in memory. However, you may influence how your JDBC driver interacts with your database through specifying a fetch size.

See Also:

Statement.setFetchSize(int)

resultSetConcurrency

ResultQuery<R> resultSetConcurrency(int resultSetConcurrency)

Specify the ResultSet concurrency of ResultSet objects created by jOOQ.

This will affect the way you may perceive ResultSet objects obtained from any of these methods:

• fetchResultSet()
• Cursor.resultSet()
• ExecuteContext.resultSet()

See Also:

Statement.getResultSetConcurrency()

resultSetType

ResultQuery<R> resultSetType(int resultSetType)

Specify the ResultSet type of ResultSet objects created by jOOQ.

This will affect the way you may perceive ResultSet objects obtained from any of these methods:

• fetchResultSet()
• Cursor.resultSet()
• ExecuteContext.resultSet()

See Also:

Statement.getResultSetType()

resultSetHoldability

ResultQuery<R> resultSetHoldability(int resultSetHoldability)

Specify the ResultSet holdability of ResultSet objects created by jOOQ.

This will affect the way you may perceive ResultSet objects obtained from any of these methods:

• fetchResultSet()
• Cursor.resultSet()
• ExecuteContext.resultSet()

See Also:

Statement.getResultSetHoldability()

intern

ResultQuery<R> intern(Field<?>... fields)

Specify a set of fields whose values should be interned.

Unlike Result's intern() methods, this already interns values right after fetching them from a JDBC result set. See Result.intern(int...) for more details.

Parameters:

fields - The fields whose values should be interned

Returns:

The same result query

See Also:

Result.intern(Field...), String.intern()

intern

ResultQuery<R> intern(int... fieldIndexes)

Specify a set of field indexes whose values should be interned.

Unlike Result's intern() methods, this already interns values right after fetching them from a JDBC result set. See Result.intern(int...) for more details.

Parameters:

fieldIndexes - The field indexes whose values should be interned

Returns:

The same result query

See Also:

Result.intern(int...), String.intern()

intern

ResultQuery<R> intern(String... fieldNames)

Specify a set of field names whose values should be interned.

Unlike Result's intern() methods, this already interns values right after fetching them from a JDBC result set. See Result.intern(int...) for more details.

Parameters:

fieldNames - The field names whose values should be interned

Returns:

The same result query

See Also:

Result.intern(String...), String.intern()