org.jooq

Interface Result<R extends Record>

Type Parameters:

R - The record type contained in this result

All Superinterfaces:

Attachable, Collection<R>, Iterable<R>, List<R>, Serializable

public interface Result<R extends Record>
extends List<R>, Attachable

A wrapper for database results returned by SelectQuery

Author:

Lukas Eder

See Also:

ResultQuery.getResult()

Method Summary

Methods

Modifier and Type	Method and Description
<T> Field<T>	field(Field<T> field) Get a specific field from this Result.
Field<?>	field(int index) Get a specific field from this Result.
Field<?>	field(String name) Get a specific field from this Result.
Field<?>[]	fields() Get all fields from this Result.
Row	fieldsRow() Get this result's fields as a Row.
String	format() Get a simple formatted representation of this result.
String	format(int maxRecords) Get a simple formatted representation of this result.
String	formatCSV() Get a simple formatted representation of this result as CSV.
String	formatCSV(char delimiter) Get a simple formatted representation of this result as CSV.
String	formatCSV(char delimiter, String nullString) Get a simple formatted representation of this result as CSV.
String	formatHTML() Get a simple formatted representation of this result as HTML.
String	formatJSON() Get a simple formatted representation of this result as a JSON array of array.
String	formatXML() Get this result formatted as XML.
<T> T	getValue(int index, Field<T> field) Convenience method to fetch a value at a given position in the result.
<T> T	getValue(int index, Field<T> field, T defaultValue) Deprecated. - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
Object	getValue(int index, int fieldIndex) Convenience method to fetch a value at a given position in the result.
Object	getValue(int index, int fieldIndex, Object defaultValue) Deprecated. - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
Object	getValue(int index, String fieldName) Convenience method to fetch a value at a given position in the result.
Object	getValue(int index, String fieldName, Object defaultValue) Deprecated. - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
<T> List<T>	getValues(Field<?> field, Class<? extends T> type) Convenience method to fetch all values for a given field.
<T> List<T>	getValues(Field<T> field) Convenience method to fetch all values for a given field.
<T,U> List<U>	getValues(Field<T> field, Converter<? super T,U> converter) Convenience method to fetch all values for a given field.
List<?>	getValues(int fieldIndex) Convenience method to fetch all values for a given field.
<T> List<T>	getValues(int fieldIndex, Class<? extends T> type) Convenience method to fetch all values for a given field.
<U> List<U>	getValues(int fieldIndex, Converter<?,U> converter) Convenience method to fetch all values for a given field.
List<?>	getValues(String fieldName) Convenience method to fetch all values for a given field.
<T> List<T>	getValues(String fieldName, Class<? extends T> type) Convenience method to fetch all values for a given field.
<U> List<U>	getValues(String fieldName, Converter<?,U> converter) Convenience method to fetch all values for a given field.
Result<R>	intern(Field<?>... fields) Specify a set of fields whose values should be interned.
Result<R>	intern(int... fieldIndexes) Specify a set of field indexes whose values should be interned.
Result<R>	intern(String... fieldNames) Specify a set of field names whose values should be interned.
<E> List<E>	into(Class<? extends E> type) Map resulting records onto a custom type.
<H extends RecordHandler<? super R>> H	into(H handler) Map results into a custom handler callback.
<Z extends Record> Result<Z>	into(Table<Z> table) Map resulting records onto a custom record.
Object[][]	intoArray() Convert this result into an array of arrays.
<T> T[]	intoArray(Field<?> field, Class<? extends T> type) Return all values for a field from the result.
<T> T[]	intoArray(Field<T> field) Return all values for a field from the result.
<T,U> U[]	intoArray(Field<T> field, Converter<? super T,U> converter) Return all values for a field from the result.
Object[]	intoArray(int fieldIndex) Return all values for a field index from the result.
<T> T[]	intoArray(int fieldIndex, Class<? extends T> type) Return all values for a field index from the result.
<U> U[]	intoArray(int fieldIndex, Converter<?,U> converter) Return all values for a field index from the result.
Object[]	intoArray(String fieldName) Return all values for a field name from the result.
<T> T[]	intoArray(String fieldName, Class<? extends T> type) Return all values for a field name from the result.
<U> U[]	intoArray(String fieldName, Converter<?,U> converter) Return all values for a field name from the result.
Map<Record,Result<R>>	intoGroups(Field<?>[] keys) Return a Map with the result grouped by the given keys.
<E> Map<Record,List<E>>	intoGroups(Field<?>[] keys, Class<? extends E> type) Return a Map with results grouped by the given keys and mapped into the given entity type.
<E> Map<Record,List<E>>	intoGroups(Field<?>[] keys, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given keys and mapped into the given entity type.
<K> Map<K,Result<R>>	intoGroups(Field<K> key) 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>>	intoGroups(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>>	intoGroups(Field<K> key, Field<V> value) Return a Map with one of the result's columns as key and another one of the result's columns as value.
<K,E> Map<K,List<E>>	intoGroups(Field<K> key, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given key and mapped by the given mapper.
Map<Record,R>	intoMap(Field<?>[] keys) Return a Map with the given keys as a map key and the corresponding record as value.
<E> Map<List<?>,E>	intoMap(Field<?>[] keys, Class<? extends E> type) Return a Map with results grouped by the given keys and mapped into the given entity type.
<E> Map<List<?>,E>	intoMap(Field<?>[] keys, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given keys and mapped by the given mapper
<K> Map<K,R>	intoMap(Field<K> key) Return a Map with one of the result's columns as key and the corresponding records as value.
<K,E> Map<K,E>	intoMap(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,V>	intoMap(Field<K> key, Field<V> value) Return a Map with one of the result's columns as key and another one of the result's columns as value An InvalidResultException is thrown, if the key turns out to be non-unique in the result set.
<K,E> Map<K,E>	intoMap(Field<K> key, RecordMapper<? super R,E> mapper) Return a Map with results grouped by the given key and mapped by the given mapper.
List<Map<String,Object>>	intoMaps() Return the generated result as a list of name/value maps.
ResultSet	intoResultSet() Generate an in-memory JDBC ResultSet containing the data of this Result.
Document	intoXML() Get this result as XML.
<H extends ContentHandler> H	intoXML(H handler) Get this result as XML using a SAX ContentHandler.
boolean	isEmpty() Whether there are any records contained in this Result.
boolean	isNotEmpty() Whether there are any records contained in this Result.
<E> List<E>	map(RecordMapper<? super R,E> mapper) Map results into a custom mapper callback.
RecordType<R>	recordType() Get this result's record type.
Result<R>	sortAsc(Comparator<? super R> comparator) Sort this result using a comparator that can compare records.
<T extends Comparable<? super T>> Result<R>	sortAsc(Field<T> field) Sort this result by one of its contained fields.
<T> Result<R>	sortAsc(Field<T> field, Comparator<? super T> comparator) Sort this result by one of its contained fields using a comparator.
Result<R>	sortAsc(int fieldIndex) Sort this result by one of its contained fields.
Result<R>	sortAsc(int fieldIndex, Comparator<?> comparator) Sort this result by one of its contained fields using a comparator.
Result<R>	sortAsc(String fieldName) Sort this result by one of its contained fields.
Result<R>	sortAsc(String fieldName, Comparator<?> comparator) Sort this result by one of its contained fields using a comparator.
Result<R>	sortDesc(Comparator<? super R> comparator) Reverse-sort this result using a comparator that can compare records.
<T extends Comparable<? super T>> Result<R>	sortDesc(Field<T> field) Reverse-sort this result by one of its contained fields.
<T> Result<R>	sortDesc(Field<T> field, Comparator<? super T> comparator) Reverse-sort this result by one of its contained fields using a comparator.
Result<R>	sortDesc(int fieldIndex) Reverse-sort this result by one of its contained fields.
Result<R>	sortDesc(int fieldIndex, Comparator<?> comparator) Reverse-sort this result by one of its contained fields using a comparator.
Result<R>	sortDesc(String fieldName) Reverse-sort this result by one of its contained fields.
Result<R>	sortDesc(String fieldName, Comparator<?> comparator) Reverse-sort this result by one of its contained fields using a comparator.

Methods inherited from interface java.util.List

add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, retainAll, set, size, subList, toArray, toArray

Methods inherited from interface org.jooq.Attachable

attach, detach

Method Detail

recordType

RecordType<R> recordType()

Get this result's record type.

fieldsRow

Row fieldsRow()

Get this result's fields as a Row.

field

<T> Field<T> field(Field<T> field)

Get a specific field from this Result.

See Also:

Row.field(Field)

field

Field<?> field(String name)

Get a specific field from this Result.

See Also:

Row.field(String)

field

Field<?> field(int index)

Get a specific field from this Result.

See Also:

Row.field(int)

fields

Field<?>[] fields()

Get all fields from this Result.

See Also:

Row.fields()

getValue

<T> T getValue(int index,
             Field<T> field)
           throws IndexOutOfBoundsException,
                  IllegalArgumentException

Convenience method to fetch a value at a given position in the result.

Type Parameters:

T - The value's field's generic type parameter

Parameters:

index - The record's index

field - The value's field

Returns:

The value

Throws:

IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())

IllegalArgumentException - If the argument field is not contained in fieldsRow()

getValue

@Deprecated
<T> T getValue(int index,
                        Field<T> field,
                        T defaultValue)
           throws IndexOutOfBoundsException,
                  IllegalArgumentException

Deprecated. - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0

Convenience method to fetch a value at a given position in the result.

Type Parameters:

T - The value's field's generic type parameter

Parameters:

index - The record's index

field - The value's field

defaultValue - The default value if the value was null

Returns:

The value

Throws:

IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())

IllegalArgumentException - If the argument field is not contained in fieldsRow()

getValue

Object getValue(int index,
              int fieldIndex)
                throws IndexOutOfBoundsException,
                       IllegalArgumentException

Convenience method to fetch a value at a given position in the result.

Parameters:

index - The record's index

fieldIndex - The value's field index

Returns:

The value

Throws:

IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

getValue

@Deprecated
Object getValue(int index,
                         int fieldIndex,
                         Object defaultValue)
                throws IndexOutOfBoundsException,
                       IllegalArgumentException

Deprecated. - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0

Convenience method to fetch a value at a given position in the result.

Parameters:

index - The record's index

fieldIndex - The value's field index

defaultValue - The default value if the value was null

Returns:

The value

Throws:

IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

getValue

Object getValue(int index,
              String fieldName)
                throws IndexOutOfBoundsException,
                       IllegalArgumentException

Convenience method to fetch a value at a given position in the result.

Parameters:

index - The record's index

fieldName - The value's field name

Returns:

The value

Throws:

IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

getValue

@Deprecated
Object getValue(int index,
                         String fieldName,
                         Object defaultValue)
                throws IndexOutOfBoundsException,
                       IllegalArgumentException

Deprecated. - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0

Convenience method to fetch a value at a given position in the result.

Parameters:

index - The record's index

fieldName - The value's field name

defaultValue - The default value if the value was null

Returns:

The value

Throws:

IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

getValues

<T> List<T> getValues(Field<T> field)
                  throws IllegalArgumentException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Type Parameters:

T - The values' field's generic type parameter

Parameters:

field - The values' field

Returns:

The values

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

getValues

<T> List<T> getValues(Field<?> field,
                    Class<? extends T> type)
                  throws IllegalArgumentException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

field - The values' field

type - The type used for type conversion

Returns:

The values

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

See Also:

Record.getValue(Field, Class), Convert.convert(Object, Class)

getValues

<T,U> List<U> getValues(Field<T> field,
                      Converter<? super T,U> converter)
                  throws IllegalArgumentException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

field - The values' field

converter - The data type converter used for type conversion

Returns:

The values

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

See Also:

Record.getValue(Field, Converter), Convert.convert(Object, Converter)

getValues

List<?> getValues(int fieldIndex)
                  throws IllegalArgumentException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

fieldIndex - The values' field index

Returns:

The values

Throws:

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

getValues

<T> List<T> getValues(int fieldIndex,
                    Class<? extends T> type)
                  throws IllegalArgumentException,
                         DataTypeException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

fieldIndex - The values' field index

type - The type used for type conversion

Returns:

The values

Throws:

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

Record.getValue(int, Class), Convert.convert(Object, Class)

getValues

<U> List<U> getValues(int fieldIndex,
                    Converter<?,U> converter)
                  throws IllegalArgumentException,
                         DataTypeException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

fieldIndex - The values' field index

converter - The data type converter used for type conversion

Returns:

The values

Throws:

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

Record.getValue(int, Converter), Convert.convert(Object, Converter)

getValues

List<?> getValues(String fieldName)
                  throws IllegalArgumentException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

fieldName - The values' field name

Returns:

The values

Throws:

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

getValues

<T> List<T> getValues(String fieldName,
                    Class<? extends T> type)
                  throws IllegalArgumentException,
                         DataTypeException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

fieldName - The values' field name

type - The type used for type conversion

Returns:

The values

Throws:

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

Record.getValue(String, Class), Convert.convert(Object, Class)

getValues

<U> List<U> getValues(String fieldName,
                    Converter<?,U> converter)
                  throws IllegalArgumentException,
                         DataTypeException

Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

Parameters:

fieldName - The values' field name

converter - The data type converter used for type conversion

Returns:

The values

Throws:

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

Record.getValue(String, Converter), Convert.convert(Object, Converter)

isEmpty

boolean isEmpty()

Whether there are any records contained in this Result.

Specified by:

isEmpty in interface Collection<R extends Record>

Specified by:

isEmpty in interface List<R extends Record>

isNotEmpty

boolean isNotEmpty()

Whether there are any records contained in this Result.

format

String format()

Get a simple formatted representation of this result.

This is the same as calling format(int) with maxRows = 50

Returns:

The formatted result

format

String format(int maxRecords)

Get a simple formatted representation of this result.

Parameters:

maxRecords - The maximum number of records to include in the formatted result

Returns:

The formatted result

formatHTML

String formatHTML()

Get a simple formatted representation of this result as HTML.

The HTML code is formatted as follows:

 <table>
   <thead>
     <tr>
       <th>field-1</th>
       <th>field-2</th>
       ...
       <th>field-n</th>
     </tr>
   </thead>
   <tbody>
     <tr>
       <th>value-1-1</th>
       <th>value-1-2</th>
       ...
       <th>value-1-n</th>
     </tr>
     <tr>
       <th>value-2-1</th>
       <th>value-2-2</th>
       ...
       <th>value-2-n</th>
     </tr>
     ...
   </tbody>
 </table>
 

Returns:

The formatted result

formatCSV

String formatCSV()

Get a simple formatted representation of this result as CSV.

This is the same as calling formatCSV(',', "")

Returns:

The formatted result

formatCSV

String formatCSV(char delimiter)

Get a simple formatted representation of this result as CSV.

This is the same as calling formatCSV(delimiter, "")

Parameters:

delimiter - The delimiter to use between records

Returns:

The formatted result

formatCSV

String formatCSV(char delimiter,
               String nullString)

Get a simple formatted representation of this result as CSV.

Parameters:

delimiter - The delimiter to use between records

nullString - A special string for encoding NULL values.

Returns:

The formatted result

formatJSON

String formatJSON()

Get a simple formatted representation of this result as a JSON array of array.

The format is the following:

 {"fields":[{"name":"field-1","type":"type-1"},
            {"name":"field-2","type":"type-2"},
            ...,
            {"name":"field-n","type":"type-n"}],
  "records":[[value-1-1,value-1-2,...,value-1-n],
             [value-2-1,value-2-2,...,value-2-n]]}
 

Returns:

The formatted result

formatXML

String formatXML()

Get this result formatted as XML.

See Also:

http://www.jooq.org/xsd/jooq-export-2.6.0.xsd

intoXML

Document intoXML()

Get this result as XML.

See Also:

formatXML(), http://www.jooq.org/xsd/jooq-export-2.6.0.xsd

intoXML

<H extends ContentHandler> H intoXML(H handler)
                                 throws SAXException

Get this result as XML using a SAX ContentHandler.

Parameters:

handler - The custom content handler.

Returns:

The argument content handler is returned for convenience.

Throws:

SAXException

See Also:

formatXML(), http://www.jooq.org/xsd/jooq-export-2.6.0.xsd

intoMaps

List<Map<String,Object>> intoMaps()

Return the generated result as a list of name/value maps.

Returns:

The result.

See Also:

Record.intoMap()

intoMap

<K> Map<K,R> intoMap(Field<K> key)
                                throws IllegalArgumentException,
                                       InvalidResultException

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

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

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:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

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

intoMap

<K,V> Map<K,V> intoMap(Field<K> key,
                     Field<V> value)
                 throws IllegalArgumentException,
                        InvalidResultException

Return a Map with one of the result's columns as key and another one of the result's columns as value

An InvalidResultException is thrown, if the key turns out to be non-unique in the result set. Use intoGroups(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:

IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

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

intoMap

Map<Record,R> intoMap(Field<?>[] keys)
                                     throws IllegalArgumentException,
                                            InvalidResultException

Return a Map with the given keys as a map key and the corresponding record as value.

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

Parameters:

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

Returns:

A Map containing the results.

Throws:

IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

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

intoMap

<K,E> Map<K,E> intoMap(Field<K> key,
                     Class<? extends E> type)
                 throws IllegalArgumentException,
                        InvalidResultException,
                        MappingException

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

An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(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:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

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

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

See Also:

DefaultRecordMapper

intoMap

<K,E> Map<K,E> intoMap(Field<K> key,
                     RecordMapper<? super R,E> mapper)
                 throws IllegalArgumentException,
                        InvalidResultException,
                        MappingException

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

An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(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:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

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

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

See Also:

DefaultRecordMapper

intoMap

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

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 intoGroups(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:

IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

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:

DefaultRecordMapper

intoMap

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

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 intoGroups(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:

IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

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:

DefaultRecordMapper

intoGroups

<K> Map<K,Result<R>> intoGroups(Field<K> key)
                                           throws IllegalArgumentException

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

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

Type Parameters:

K - The key's generic field type

Parameters:

key - The key field.

Returns:

A Map containing the results

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

intoGroups

<K,V> Map<K,List<V>> intoGroups(Field<K> key,
                              Field<V> value)
                          throws IllegalArgumentException

Return a Map with one of the result's columns as key and another one of the result's columns as value.

Unlike intoMap(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:

IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

intoGroups

Map<Record,Result<R>> intoGroups(Field<?>[] keys)
                                                throws IllegalArgumentException

Return a Map with the result grouped by the given keys.

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

Parameters:

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

Returns:

A Map containing grouped results

Throws:

IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

intoGroups

<K,E> Map<K,List<E>> intoGroups(Field<K> key,
                              Class<? extends E> type)
                          throws IllegalArgumentException,
                                 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:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

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

See Also:

DefaultRecordMapper

intoGroups

<K,E> Map<K,List<E>> intoGroups(Field<K> key,
                              RecordMapper<? super R,E> mapper)
                          throws IllegalArgumentException,
                                 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:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

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

intoGroups

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

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

Unlike intoMap(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:

IllegalArgumentException - If the any of the argument fields is not contained in fieldsRow()

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

See Also:

DefaultRecordMapper

intoGroups

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

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

Unlike intoMap(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:

IllegalArgumentException - If the any of the argument fields is not contained in fieldsRow()

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

See Also:

DefaultRecordMapper

intoArray

Object[][] intoArray()

Convert this result into an array of arrays.

The resulting array has the same number of first-dimension elements as this result has records. It has the same number of second-dimension elements as this result's records have fields. The resulting array contains data as such:

 // For arbitrary values of i, j
 result.getValue(i, j) == result.intoArray()[i][j]
 

This is the same as calling into(Object[].class)

Returns:

This result as an array of arrays

See Also:

Record.intoArray()

intoArray

Object[] intoArray(int fieldIndex)
                   throws IllegalArgumentException

Return all values for a field index from the result.

You can access data like this

result.intoArray(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:

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

See Also:

getValues(int)

intoArray

<T> T[] intoArray(int fieldIndex,
                Class<? extends T> type)
              throws IllegalArgumentException,
                     DataTypeException

Return all values for a field index from the result.

You can access data like this

result.intoArray(fieldIndex)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

getValues(int, Class)

intoArray

<U> U[] intoArray(int fieldIndex,
                Converter<?,U> converter)
              throws IllegalArgumentException,
                     DataTypeException

Return all values for a field index from the result.

You can access data like this

result.intoArray(fieldIndex)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

getValues(int, Converter)

intoArray

Object[] intoArray(String fieldName)
                   throws IllegalArgumentException

Return all values for a field name from the result.

You can access data like this

result.intoArray(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:

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

See Also:

getValues(String)

intoArray

<T> T[] intoArray(String fieldName,
                Class<? extends T> type)
              throws IllegalArgumentException,
                     DataTypeException

Return all values for a field name from the result.

You can access data like this

result.intoArray(fieldName)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

getValues(String, Class)

intoArray

<U> U[] intoArray(String fieldName,
                Converter<?,U> converter)
              throws IllegalArgumentException,
                     DataTypeException

Return all values for a field name from the result.

You can access data like this

result.intoArray(fieldName)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

getValues(String, Converter)

intoArray

<T> T[] intoArray(Field<T> field)
              throws IllegalArgumentException

Return all values for a field from the result.

You can access data like this

result.intoArray(field)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

See Also:

getValues(Field)

intoArray

<T> T[] intoArray(Field<?> field,
                Class<? extends T> type)
              throws IllegalArgumentException,
                     DataTypeException

Return all values for a field from the result.

You can access data like this

result.intoArray(field)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

getValues(Field, Class)

intoArray

<T,U> U[] intoArray(Field<T> field,
                  Converter<? super T,U> converter)
              throws IllegalArgumentException,
                     DataTypeException

Return all values for a field from the result.

You can access data like this

result.intoArray(field)[recordIndex]

Returns:

The resulting values.

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

DataTypeException - wrapping any data type conversion exception that might have occurred

See Also:

getValues(Field, Converter)

into

<E> List<E> into(Class<? extends E> type)
             throws MappingException

Map resulting records onto a custom type.

This is the same as calling record.into(type) on every record contained in this Result. See Record.into(Class) for more details

Type Parameters:

E - The generic entity type.

Parameters:

type - The entity type.

Throws:

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

See Also:

Record.into(Class), DefaultRecordMapper

into

<Z extends Record> Result<Z> into(Table<Z> table)
                              throws MappingException

Map resulting records onto a custom record.

This is the same as calling record.into(table) on every record contained in this Result. See Record.into(Table) for more details

Type Parameters:

Z - The generic table record type.

Parameters:

table - The table type.

Throws:

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

See Also:

Record.into(Table)

into

<H extends RecordHandler<? super R>> H into(H handler)

Map results into a custom handler callback.

Parameters:

handler - The handler callback

Returns:

Convenience result, returning the parameter handler itself

intoResultSet

ResultSet intoResultSet()

Generate an in-memory JDBC ResultSet containing the data of this Result.

Use this as an adapter for JDBC-compliant code that expects a ResultSet to operate on, rather than a jOOQ Result. The returned ResultSet allows for the following behaviour according to the JDBC specification:

• ResultSet.CLOSE_CURSORS_AT_COMMIT: The cursors (i.e. Statement object) are no longer available
• ResultSet.CONCUR_READ_ONLY: You cannot update the database through this ResultSet, as the underlying Result object does not hold any open database refences anymore
• ResultSet.FETCH_FORWARD: The fetch direction is forward only, and cannot be changed
• ResultSet.TYPE_SCROLL_INSENSITIVE: You can use any of the ResultSet's scrolling methods, e.g. ResultSet.next() or ResultSet.previous(), etc.

You may use DSLContext.fetch(ResultSet) to unwind this wrapper again.

Returns:

A wrapper JDBC ResultSet

map

<E> List<E> map(RecordMapper<? super R,E> mapper)

Map results into a custom mapper callback.

Parameters:

mapper - The mapper callback

Returns:

The custom mapped records

sortAsc

<T extends Comparable<? super T>> Result<R> sortAsc(Field<T> field)
                                 throws IllegalArgumentException

Sort this result by one of its contained fields.

nulls are sorted last by this method.

Parameters:

field - The sort field

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortDesc

<T extends Comparable<? super T>> Result<R> sortDesc(Field<T> field)
                                  throws IllegalArgumentException

Reverse-sort this result by one of its contained fields.

nulls are sorted last by this method.

Parameters:

field - The sort field

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortAsc

Result<R> sortAsc(int fieldIndex)
                                 throws IllegalArgumentException

Sort this result by one of its contained fields.

nulls are sorted last by this method.

Parameters:

fieldIndex - The sort field index

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortDesc

Result<R> sortDesc(int fieldIndex)
                                  throws IllegalArgumentException

Reverse-sort this result by one of its contained fields.

nulls are sorted last by this method.

Parameters:

fieldIndex - The sort field index

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortAsc

Result<R> sortAsc(String fieldName)
                                 throws IllegalArgumentException

Sort this result by one of its contained fields.

nulls are sorted last by this method.

Parameters:

fieldName - The sort field name

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortDesc

Result<R> sortDesc(String fieldName)
                                  throws IllegalArgumentException

Reverse-sort this result by one of its contained fields.

nulls are sorted last by this method.

Parameters:

fieldName - The sort field name

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortAsc

<T> Result<R> sortAsc(Field<T> field,
                    Comparator<? super T> comparator)
                                 throws IllegalArgumentException

Sort this result by one of its contained fields using a comparator.

null sorting must be handled by the supplied comparator.

Parameters:

field - The sort field

comparator - The comparator used to sort this result.

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortDesc

<T> Result<R> sortDesc(Field<T> field,
                     Comparator<? super T> comparator)
                                  throws IllegalArgumentException

Reverse-sort this result by one of its contained fields using a comparator.

null sorting must be handled by the supplied comparator.

Parameters:

field - The sort field

comparator - The comparator used to sort this result.

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortAsc

Result<R> sortAsc(int fieldIndex,
                Comparator<?> comparator)
                                 throws IllegalArgumentException

Sort this result by one of its contained fields using a comparator.

null sorting must be handled by the supplied comparator.

Parameters:

fieldIndex - The sort field index

comparator - The comparator used to sort this result.

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortDesc

Result<R> sortDesc(int fieldIndex,
                 Comparator<?> comparator)
                                  throws IllegalArgumentException

Reverse-sort this result by one of its contained fields using a comparator.

null sorting must be handled by the supplied comparator.

Parameters:

fieldIndex - The sort field index

comparator - The comparator used to sort this result.

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortAsc

Result<R> sortAsc(String fieldName,
                Comparator<?> comparator)
                                 throws IllegalArgumentException

Sort this result by one of its contained fields using a comparator.

null sorting must be handled by the supplied comparator.

Parameters:

fieldName - The sort field name

comparator - The comparator used to sort this result.

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortDesc

Result<R> sortDesc(String fieldName,
                 Comparator<?> comparator)
                                  throws IllegalArgumentException

Reverse-sort this result by one of its contained fields using a comparator.

null sorting must be handled by the supplied comparator.

Parameters:

fieldName - The sort field name

comparator - The comparator used to sort this result.

Returns:

The result itself

Throws:

IllegalArgumentException - If the argument field is not contained in fieldsRow()

sortAsc

Result<R> sortAsc(Comparator<? super R> comparator)

Sort this result using a comparator that can compare records.

Parameters:

comparator - The comparator used to sort this result.

Returns:

The result itself

sortDesc

Result<R> sortDesc(Comparator<? super R> comparator)

Reverse-sort this result using a comparator that can compare records.

Parameters:

comparator - The comparator used to sort this result.

Returns:

The result itself

intern

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

Specify a set of fields whose values should be interned.

See intern(int...) for more details.

Parameters:

fields - The fields whose values should be interned

Returns:

The same result

See Also:

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

intern

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

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

This traverses all records and interns String values for a given set of field indexes. Use this method to save memory when a large result set contains many identical string literals.

Please refer to String.intern() and to publicly available literature to learn more about potential side-effects of string interning.

Future versions of jOOQ may also "intern" other data types, such as Integer, Long, within a Result object.

Parameters:

fieldIndexes - The field indexes whose values should be interned

Returns:

The same result

See Also:

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

intern

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

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

See intern(int...) for more details.

Parameters:

fieldNames - The field names whose values should be interned

Returns:

The same result

See Also:

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