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

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 This is the same as calling Query.execute() and then getResult()
<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.
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]
<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
<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.
<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,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();

Methods inherited from interface org.jooq.Query

execute, getBindValues, getParam, getParams, getSQL, getSQL

Methods inherited from interface org.jooq.Attachable

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

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'";

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:

Store.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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 Store.getValue(int)

Returns:

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

Throws:

DataAccessException - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 Store.getValue(int, Class)

Returns:

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

Throws:

DataAccessException - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 Store.getValue(int)

Returns:

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

Throws:

DataAccessException - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one value

fetchOne

R fetchOne()
                          throws DataAccessException

Execute the query and return at most one resulting record.

Returns:

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

Throws:

DataAccessException - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one record

fetchAny

R fetchAny()
                          throws DataAccessException

Execute the query and return at most one resulting record.

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 - This exception is thrown

• if something went wrong executing the query
• if several fields share the same name

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 - This exception is thrown

• if something went wrong executing the query
• if the query returned more than one record
• if several fields share the same name

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.

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 - This exception is thrown

• if something went wrong executing the query
• if the key field returned two or more equal values from the result set.

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.

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 - This exception is thrown

• if something went wrong executing the query
• if the key field returned two or more equal values from the result set.

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

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.

Throws:

DataAccessException - if something went wrong executing the query

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

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

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.

Throws:

DataAccessException - if something went wrong executing the query

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

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

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

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

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

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 - This exception is thrown

• if something went wrong executing the query
• 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

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

Parameters:

handler - The handler callback

Returns:

Convenience result, returning the parameter handler itself

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.

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.

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

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

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