Result (jOOQ 3.8.1 API)

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

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`attach(Configuration configuration)` Attach this result and all of its contained records to a new `Configuration`.
`void`	`detach()` Detach this result and all of its contained records from their current `Configuration`.
`<O extends TableRecord<O>> Result<O>`	`fetchChildren(ForeignKey<O,R> key)` Fetch child records of this record, given a foreign key.
`<O extends UpdatableRecord<O>> Result<O>`	`fetchParents(ForeignKey<R,O> key)` Fetch parent records of this record, given a foreign key.
`<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.
`<T> Field<T>`	`field(int index, Class<T> type)` Get a specific field from this Result, coerced to `type`.
`<T> Field<T>`	`field(int index, DataType<T> dataType)` Get a specific field from this Result, coerced to `dataType`.
`Field<?>`	`field(Name name)` Get a specific field from this Result.
`<T> Field<T>`	`field(Name name, Class<T> type)` Get a specific field from this Result, coerced to `type`.
`<T> Field<T>`	`field(Name name, DataType<T> dataType)` Get a specific field from this Result, coerced to `dataType`.
`Field<?>`	`field(String name)` Get a specific field from this Result.
`<T> Field<T>`	`field(String name, Class<T> type)` Get a specific field from this Result, coerced to `type`.
`<T> Field<T>`	`field(String name, DataType<T> dataType)` Get a specific field from this Result, coerced to `dataType`.
`Field<?>[]`	`fields()` Get all fields from this Result.
`Field<?>[]`	`fields(Field<?>... fields)` Get all fields from this Result, providing some fields.
`Field<?>[]`	`fields(int... fieldIndexes)` Get all fields from this Result, providing some field indexes.
`Field<?>[]`	`fields(Name... fieldNames)` Get all fields from this Result, providing some field names.
`Field<?>[]`	`fields(String... fieldNames)` Get all fields from this Result, providing some field names.
`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.
`void`	`format(OutputStream stream)` Like `format()`, but the data is output onto an `OutputStream`.
`void`	`format(OutputStream stream, int maxRecords)` Like `format(int)`, but the data is output onto an `OutputStream`.
`void`	`format(Writer writer)` Like `format()`, but the data is output onto a `Writer`.
`void`	`format(Writer writer, int maxRecords)` Like `format(int)`, but the data is output onto a `Writer`.
`String`	`formatCSV()` Get a simple formatted representation of this result as CSV.
`String`	`formatCSV(boolean header)` Get a simple formatted representation of this result as CSV.
`String`	`formatCSV(boolean header, char delimiter)` Get a simple formatted representation of this result as CSV.
`String`	`formatCSV(boolean header, char delimiter, String nullString)` 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`	`formatCSV(CSVFormat format)` Get a simple formatted representation of this result as CSV.
`void`	`formatCSV(OutputStream stream)` Like `formatCSV()`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(OutputStream stream, boolean header)` Like `formatCSV(boolean)`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(OutputStream stream, boolean header, char delimiter)` Like `formatCSV(boolean, char)`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(OutputStream stream, boolean header, char delimiter, String nullString)` Like `formatCSV(boolean, char, String)`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(OutputStream stream, char delimiter)` Like `formatCSV(char)`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(OutputStream stream, char delimiter, String nullString)` Like `formatCSV(char, String)`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(OutputStream stream, CSVFormat format)` Like `formatCSV(CSVFormat)`, but the data is output onto an `OutputStream`.
`void`	`formatCSV(Writer writer)` Like `formatCSV()`, but the data is output onto a `Writer`.
`void`	`formatCSV(Writer writer, boolean header)` Like `formatCSV(boolean)`, but the data is output onto a `Writer`.
`void`	`formatCSV(Writer writer, boolean header, char delimiter)` Like `formatCSV(boolean, char)`, but the data is output onto a `Writer`.
`void`	`formatCSV(Writer writer, boolean header, char delimiter, String nullString)` Like `formatCSV(boolean, char, String)`, but the data is output onto a `Writer`.
`void`	`formatCSV(Writer writer, char delimiter)` Like `formatCSV(char)`, but the data is output onto a `Writer`.
`void`	`formatCSV(Writer writer, char delimiter, String nullString)` Like `formatCSV(char, String)`, but the data is output onto a `Writer`.
`void`	`formatCSV(Writer writer, CSVFormat format)` Like `formatCSV(CSVFormat)`, but the data is output onto a `Writer`.
`String`	`formatHTML()` Get a simple formatted representation of this result as HTML.
`void`	`formatHTML(OutputStream stream)` Like `formatHTML()`, but the data is output onto an `OutputStream`.
`void`	`formatHTML(Writer writer)` Like `formatHTML()`, but the data is output onto a `Writer`.
`String`	`formatInsert()` Get this result as a set of `INSERT` statements.
`void`	`formatInsert(OutputStream stream)` Like `formatInsert()`, but the data is output onto an `OutputStream`.
`void`	`formatInsert(OutputStream stream, Table<?> table, Field<?>... fields)` Like `formatInsert(Table, Field...)`, but the data is output onto an `OutputStream`.
`String`	`formatInsert(Table<?> table, Field<?>... fields)` Get this result as a set of `INSERT` statements.
`void`	`formatInsert(Writer writer)` Like `formatInsert()`, but the data is output onto a `Writer`.
`void`	`formatInsert(Writer writer, Table<?> table, Field<?>... fields)` Like `formatInsert(Table, Field...)`, but the data is output onto an `Writer`.
`String`	`formatJSON()` Get a simple formatted representation of this result as a JSON array of array.
`void`	`formatJSON(OutputStream stream)` Like `formatJSON()`, but the data is output onto an `OutputStream`.
`void`	`formatJSON(Writer writer)` Like `formatJSON()`, but the data is output onto a `Writer`.
`String`	`formatXML()` Get this result formatted as XML.
`void`	`formatXML(OutputStream stream)` Like `formatXML()`, but the data is output onto an `OutputStream`.
`void`	`formatXML(Writer writer)` Like `formatXML()`, but the data is output onto a `Writer`.
`<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(Name fieldName)` Convenience method to fetch all values for a given field.
`<T> List<T>`	`getValues(Name fieldName, Class<? extends T> type)` Convenience method to fetch all values for a given field.
`<U> List<U>`	`getValues(Name fieldName, 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(Name... fieldNames)` Specify a set of field names 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.
`Result<Record>`	`into(Field<?>... fields)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1> Result<Record1<T1>>`	`into(Field<T1> field1)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2> Result<Record2<T1,T2>>`	`into(Field<T1> field1, Field<T2> field2)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3> Result<Record3<T1,T2,T3>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4> Result<Record4<T1,T2,T3,T4>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5> Result<Record5<T1,T2,T3,T4,T5>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6> Result<Record6<T1,T2,T3,T4,T5,T6>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7> Result<Record7<T1,T2,T3,T4,T5,T6,T7>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8> Result<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9> Result<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Result<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Result<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Result<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Result<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Result<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Result<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Result<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Result<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Result<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Result<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Result<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Result<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Result<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>`	`into(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)` Copy all records from this result into a new result with new records holding only a subset of the previous fields.
`<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()` Deprecated. - 3.6.0 - [#3879] - Use `intoArrays()` instead.
`<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(Name fieldName)` Return all values for a field name from the result.
`<T> T[]`	`intoArray(Name fieldName, Class<? extends T> type)` Return all values for a field name from the result.
`<U> U[]`	`intoArray(Name fieldName, Converter<?,U> converter)` Return all values for a field name 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.
`Object[][]`	`intoArrays()` Convert this result into an array of arrays.
`<K> Map<K,Result<R>>`	`intoGroups(Class<? extends K> keyType)` Return a `Map` with results grouped by the given key entity.
`<K,V> Map<K,List<V>>`	`intoGroups(Class<? extends K> keyType, Class<? extends V> valueType)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`<K,V> Map<K,List<V>>`	`intoGroups(Class<? extends K> keyType, RecordMapper<? super R,V> valueMapper)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`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<?,Result<R>>`	`intoGroups(int keyFieldIndex)` Return a `Map` with one of the result's columns as key and a list of corresponding records as value.
`Map<Record,Result<R>>`	`intoGroups(int[] keyFieldIndexes)` Return a `Map` with the result grouped by the given keys.
`<E> Map<Record,List<E>>`	`intoGroups(int[] keyFieldIndexes, 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(int[] keyFieldIndexes, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given keys and mapped into the given entity type.
`<E> Map<?,List<E>>`	`intoGroups(int keyFieldIndex, Class<? extends E> type)` Return a `Map` with results grouped by the given key and mapped into the given entity type.
`Map<?,List<?>>`	`intoGroups(int keyFieldIndex, int valueFieldIndex)` Return a `Map` with one of the result's columns as key and another one of the result's columns as value.
`<E> Map<?,List<E>>`	`intoGroups(int keyFieldIndex, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key and mapped by the given mapper.
`Map<?,Result<R>>`	`intoGroups(Name keyFieldName)` Return a `Map` with one of the result's columns as key and a list of corresponding records as value.
`Map<Record,Result<R>>`	`intoGroups(Name[] keyFieldNames)` Return a `Map` with the result grouped by the given keys.
`<E> Map<Record,List<E>>`	`intoGroups(Name[] keyFieldNames, 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(Name[] keyFieldNames, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given keys and mapped into the given entity type.
`<E> Map<?,List<E>>`	`intoGroups(Name keyFieldName, Class<? extends E> type)` Return a `Map` with results grouped by the given key and mapped into the given entity type.
`Map<?,List<?>>`	`intoGroups(Name keyFieldName, Name valueFieldName)` Return a `Map` with one of the result's columns as key and another one of the result's columns as value.
`<E> Map<?,List<E>>`	`intoGroups(Name keyFieldName, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key and mapped by the given mapper.
`<K> Map<K,Result<R>>`	`intoGroups(RecordMapper<? super R,K> keyMapper)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`<K,V> Map<K,List<V>>`	`intoGroups(RecordMapper<? super R,K> keyMapper, Class<V> valueType)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`<K,V> Map<K,List<V>>`	`intoGroups(RecordMapper<? super R,K> keyMapper, RecordMapper<? super R,V> valueMapper)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`Map<?,Result<R>>`	`intoGroups(String keyFieldName)` Return a `Map` with one of the result's columns as key and a list of corresponding records as value.
`Map<Record,Result<R>>`	`intoGroups(String[] keyFieldNames)` Return a `Map` with the result grouped by the given keys.
`<E> Map<Record,List<E>>`	`intoGroups(String[] keyFieldNames, 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(String[] keyFieldNames, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given keys and mapped into the given entity type.
`<E> Map<?,List<E>>`	`intoGroups(String keyFieldName, Class<? extends E> type)` Return a `Map` with results grouped by the given key and mapped into the given entity type.
`<E> Map<?,List<E>>`	`intoGroups(String keyFieldName, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key and mapped by the given mapper.
`Map<?,List<?>>`	`intoGroups(String keyFieldName, String valueFieldName)` Return a `Map` with one of the result's columns as key and another one of the result's columns as value.
`<S extends Record> Map<S,Result<R>>`	`intoGroups(Table<S> table)` Return a `Map` with the result grouped by the given key table.
`<E,S extends Record> Map<S,List<E>>`	`intoGroups(Table<S> table, Class<? extends E> type)` Return a `Map` with results grouped by the given key table and mapped into the given entity type.
`<E,S extends Record> Map<S,List<E>>`	`intoGroups(Table<S> table, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key table and mapped into the given entity type.
`<K> Map<K,R>`	`intoMap(Class<? extends K> keyType)` Return a `Map` with results grouped by the given key entity.
`<K,V> Map<K,V>`	`intoMap(Class<? extends K> keyType, Class<? extends V> valueType)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`<K,V> Map<K,V>`	`intoMap(Class<? extends K> keyType, RecordMapper<? super R,V> valueMapper)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`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.
`Map<?,R>`	`intoMap(int keyFieldIndex)` Return a `Map` with one of the result's columns as key and the corresponding records as value.
`Map<Record,R>`	`intoMap(int[] keyFieldIndexes)` Return a `Map` with the given keys as a map key and the corresponding record as value.
`<E> Map<List<?>,E>`	`intoMap(int[] keyFieldIndexes, 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(int[] keyFieldIndexes, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given keys and mapped by the given mapper.
`<E> Map<?,E>`	`intoMap(int keyFieldIndex, Class<? extends E> type)` Return a `Map` with results grouped by the given key and mapped into the given entity type.
`Map<?,?>`	`intoMap(int keyFieldIndex, int valueFieldIndex)` 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.
`<E> Map<?,E>`	`intoMap(int keyFieldIndex, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key and mapped by the given mapper.
`Map<?,R>`	`intoMap(Name keyFieldName)` Return a `Map` with one of the result's columns as key and the corresponding records as value.
`Map<Record,R>`	`intoMap(Name[] keyFieldNames)` Return a `Map` with the given keys as a map key and the corresponding record as value.
`<E> Map<List<?>,E>`	`intoMap(Name[] keyFieldNames, 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(Name[] keyFieldNames, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given keys and mapped by the given mapper.
`<E> Map<?,E>`	`intoMap(Name keyFieldName, Class<? extends E> type)` Return a `Map` with results grouped by the given key and mapped into the given entity type.
`Map<?,?>`	`intoMap(Name keyFieldName, Name valueFieldName)` 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.
`<E> Map<?,E>`	`intoMap(Name keyFieldName, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key and mapped by the given mapper.
`<K> Map<K,R>`	`intoMap(RecordMapper<? super R,K> keyMapper)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`<K,V> Map<K,V>`	`intoMap(RecordMapper<? super R,K> keyMapper, Class<V> valueType)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`<K,V> Map<K,V>`	`intoMap(RecordMapper<? super R,K> keyMapper, RecordMapper<? super R,V> valueMapper)` Return a `Map` with results grouped by the given key entity and mapped into the given entity type.
`Map<?,R>`	`intoMap(String keyFieldName)` Return a `Map` with one of the result's columns as key and the corresponding records as value.
`Map<Record,R>`	`intoMap(String[] keyFieldNames)` Return a `Map` with the given keys as a map key and the corresponding record as value.
`<E> Map<List<?>,E>`	`intoMap(String[] keyFieldNames, 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(String[] keyFieldNames, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given keys and mapped by the given mapper.
`<E> Map<?,E>`	`intoMap(String keyFieldName, Class<? extends E> type)` Return a `Map` with results grouped by the given key and mapped into the given entity type.
`<E> Map<?,E>`	`intoMap(String keyFieldName, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key and mapped by the given mapper.
`Map<?,?>`	`intoMap(String keyFieldName, String valueFieldName)` 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.
`<S extends Record> Map<S,R>`	`intoMap(Table<S> table)` Return a `Map` with the given key table as a map key and the corresponding record as value.
`<E,S extends Record> Map<S,E>`	`intoMap(Table<S> table, Class<? extends E> type)` Return a `Map` with results grouped by the given key table and mapped into the given entity type.
`<E,S extends Record> Map<S,E>`	`intoMap(Table<S> table, RecordMapper<? super R,E> mapper)` Return a `Map` with results grouped by the given key table 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`.
`<T> Set<T>`	`intoSet(Field<?> field, Class<? extends T> type)` Return all values for a field from the result.
`<T> Set<T>`	`intoSet(Field<T> field)` Return all values for a field from the result.
`<T,U> Set<U>`	`intoSet(Field<T> field, Converter<? super T,U> converter)` Return all values for a field from the result.
`Set<?>`	`intoSet(int fieldIndex)` Return all values for a field index from the result.
`<T> Set<T>`	`intoSet(int fieldIndex, Class<? extends T> type)` Return all values for a field index from the result.
`<U> Set<U>`	`intoSet(int fieldIndex, Converter<?,U> converter)` Return all values for a field index from the result.
`Set<?>`	`intoSet(Name fieldName)` Return all values for a field name from the result.
`<T> Set<T>`	`intoSet(Name fieldName, Class<? extends T> type)` Return all values for a field name from the result.
`<U> Set<U>`	`intoSet(Name fieldName, Converter<?,U> converter)` Return all values for a field name from the result.
`Set<?>`	`intoSet(String fieldName)` Return all values for a field name from the result.
`<T> Set<T>`	`intoSet(String fieldName, Class<? extends T> type)` Return all values for a field name from the result.
`<U> Set<U>`	`intoSet(String fieldName, Converter<?,U> converter)` Return all values for a field name from the 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(Name fieldName)` Sort this result by one of its contained fields.
`Result<R>`	`sortAsc(Name fieldName, 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(Name fieldName)` Reverse-sort this result by one of its contained fields.
`Result<R>`	`sortDesc(Name fieldName, 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, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

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.
Usually, this will return the field itself. However, if this is a row from an aliased table, the field will be aliased accordingly.

See Also:

Row.field(Field)

field
```
Field<?> field(String name)
```
Get a specific field from this Result.

See Also:

Row.field(String)

field

<T> Field<T> field(String name,
                   Class<T> type)

Get a specific field from this Result, coerced to type.

See Also:: Row.field(String, Class)

field

<T> Field<T> field(String name,
                   DataType<T> dataType)

Get a specific field from this Result, coerced to dataType.

See Also:: Row.field(String, DataType)

field
```
Field<?> field(Name name)
```
Get a specific field from this Result.

See Also:

Row.field(Name)

field

<T> Field<T> field(Name name,
                   Class<T> type)

Get a specific field from this Result, coerced to type.

See Also:: Row.field(Name, Class)

field

<T> Field<T> field(Name name,
                   DataType<T> dataType)

Get a specific field from this Result, coerced to dataType.

See Also:: Row.field(Name, DataType)

field
```
Field<?> field(int index)
```
Get a specific field from this Result.

See Also:

Row.field(int)

field

<T> Field<T> field(int index,
                   Class<T> type)

Get a specific field from this Result, coerced to type.

See Also:: Row.field(int, Class)

field

<T> Field<T> field(int index,
                   DataType<T> dataType)

Get a specific field from this Result, coerced to dataType.

See Also:: Row.field(int, DataType)

fields
```
Field<?>[] fields()
```
Get all fields from this Result.

See Also:

Row.fields()

fields
```
Field<?>[] fields(Field<?>... fields)
```
Get all fields from this Result, providing some fields.

Returns:

All available fields

See Also:

Row.fields(Field...)

fields
```
Field<?>[] fields(String... fieldNames)
```
Get all fields from this Result, providing some field names.

Returns:

All available fields

See Also:

Row.fields(String...)

fields
```
Field<?>[] fields(Name... fieldNames)
```
Get all fields from this Result, providing some field names.

Returns:

All available fields

See Also:

Row.fields(Name...)

fields
```
Field<?>[] fields(int... fieldIndexes)
```
Get all fields from this Result, providing some field indexes.

Returns:

All available fields

See Also:

Row.fields(int...)

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.get(Field, Class), Convert.convert(Object, Class)

getValues
```
<T,U> List 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.get(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.get(int, Class), Convert.convert(Object, Class)

getValues
```
 List 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.get(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.get(String, Class), Convert.convert(Object, Class)

getValues
```
 List 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.get(String, Converter), Convert.convert(Object, Converter)

getValues
```
List<?> getValues(Name 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(Name 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.get(Name, Class), Convert.convert(Object, Class)

getValues
```
 List getValues(Name 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.get(Name, 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(true, ',', "")

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(true, 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.
This is the same as calling formatCSV(true, delimiter, nullString)

Parameters:

delimiter - The delimiter to use between records

nullString - A special string for encoding NULL values.

Returns:

The formatted result

formatCSV
```
String formatCSV(boolean header)
```
Get a simple formatted representation of this result as CSV.
This is the same as calling formatCSV(',', "")

Parameters:

header - Whether to emit a CSV header line

Returns:

The formatted result

formatCSV
```
String formatCSV(boolean header,
                 char delimiter)
```
Get a simple formatted representation of this result as CSV.
This is the same as calling formatCSV(delimiter, "")

Parameters:

header - Whether to emit a CSV header line

delimiter - The delimiter to use between records

Returns:

The formatted result

formatCSV
```
String formatCSV(boolean header,
                 char delimiter,
                 String nullString)
```
Get a simple formatted representation of this result as CSV.

Parameters:

header - Whether to emit a CSV header line

delimiter - The delimiter to use between records

nullString - A special string for encoding NULL values.

Returns:

The formatted result

formatCSV
```
String formatCSV(CSVFormat format)
```
Get a simple formatted representation of this result as CSV.

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

formatInsert
```
String formatInsert()
```
Get this result as a set of INSERT statements.
This uses the the first record's TableRecord.getTable(), if the first record is a TableRecord. Otherwise, this generates INSERT statements into an "UNKNOWN_TABLE". In both cases, the fields() are used for column names.

formatInsert
```
String formatInsert(Table<?> table,
 Field<?>... fields)
```
Get this result as a set of INSERT statements.
This explicitly specifies the table (and optionally the fields) to insert into. If the fields argument is left empty, the fields() are used, instead.

format
```
void format(OutputStream stream)
     throws IOException
```
Like format(), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

format
```
void format(OutputStream stream,
            int maxRecords)
     throws IOException
```
Like format(int), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatHTML
```
void formatHTML(OutputStream stream)
         throws IOException
```
Like formatHTML(), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(OutputStream stream)
        throws IOException
```
Like formatCSV(), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(OutputStream stream,
               char delimiter)
        throws IOException
```
Like formatCSV(char), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(OutputStream stream,
               char delimiter,
               String nullString)
        throws IOException
```
Like formatCSV(char, String), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(OutputStream stream,
               boolean header)
        throws IOException
```
Like formatCSV(boolean), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(OutputStream stream,
               boolean header,
               char delimiter)
        throws IOException
```
Like formatCSV(boolean, char), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV

void formatCSV(OutputStream stream,
               boolean header,
               char delimiter,
               String nullString)
        throws IOException

Like formatCSV(boolean, char, String), but the data is output onto an OutputStream.

Throws:: IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(OutputStream stream,
               CSVFormat format)
        throws IOException
```
Like formatCSV(CSVFormat), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatJSON
```
void formatJSON(OutputStream stream)
         throws IOException
```
Like formatJSON(), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatXML
```
void formatXML(OutputStream stream)
        throws IOException
```
Like formatXML(), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatInsert
```
void formatInsert(OutputStream stream)
           throws IOException
```
Like formatInsert(), but the data is output onto an OutputStream.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatInsert

void formatInsert(OutputStream stream,
                  Table<?> table,
                  Field<?>... fields)
           throws IOException

Like formatInsert(Table, Field...), but the data is output onto an OutputStream.

Throws:: IOException - - an unchecked wrapper for IOException, if anything goes wrong.

format
```
void format(Writer writer)
     throws IOException
```
Like format(), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

format
```
void format(Writer writer,
            int maxRecords)
     throws IOException
```
Like format(int), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatHTML
```
void formatHTML(Writer writer)
         throws IOException
```
Like formatHTML(), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(Writer writer)
        throws IOException
```
Like formatCSV(), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(Writer writer,
               char delimiter)
        throws IOException
```
Like formatCSV(char), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(Writer writer,
               char delimiter,
               String nullString)
        throws IOException
```
Like formatCSV(char, String), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(Writer writer,
               boolean header)
        throws IOException
```
Like formatCSV(boolean), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(Writer writer,
               boolean header,
               char delimiter)
        throws IOException
```
Like formatCSV(boolean, char), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV

void formatCSV(Writer writer,
               boolean header,
               char delimiter,
               String nullString)
        throws IOException

Like formatCSV(boolean, char, String), but the data is output onto a Writer.

Throws:: IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatCSV
```
void formatCSV(Writer writer,
               CSVFormat format)
        throws IOException
```
Like formatCSV(CSVFormat), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatJSON
```
void formatJSON(Writer writer)
         throws IOException
```
Like formatJSON(), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatXML
```
void formatXML(Writer writer)
        throws IOException
```
Like formatXML(), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatInsert
```
void formatInsert(Writer writer)
           throws IOException
```
Like formatInsert(), but the data is output onto a Writer.

Throws:

IOException - - an unchecked wrapper for IOException, if anything goes wrong.

formatInsert

void formatInsert(Writer writer,
                  Table<?> table,
                  Field<?>... fields)
           throws IOException

Like formatInsert(Table, Field...), but the data is output onto an Writer.

Throws:: IOException - - an unchecked wrapper for IOException, if anything goes wrong.

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
```
Map<?,R> intoMap(int keyFieldIndex)
 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(int) instead, if your keys are non-unique

Parameters:

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

Returns:

A Map containing the results

Throws:

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

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

intoMap
```
Map<?,R> intoMap(String keyFieldName)
 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(String) instead, if your keys are non-unique

Parameters:

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

Returns:

A Map containing the results

Throws:

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

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

intoMap
```
Map<?,R> intoMap(Name keyFieldName)
 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(Name) instead, if your keys are non-unique

Parameters:

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

Returns:

A Map containing the results

Throws:

IllegalArgumentException - If the argument keyFieldName 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<?,?> intoMap(int keyFieldIndex,
 int valueFieldIndex)
 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(int, int) instead, if your keys are non-unique

Parameters:

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

valueFieldIndex - The value field index

Returns:

A Map containing the results

Throws:

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

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

intoMap
```
Map<?,?> intoMap(String keyFieldName,
 String valueFieldName)
 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(String, String) instead, if your keys are non-unique

Parameters:

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

value - The value field name

Returns:

A Map containing the results

Throws:

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

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

intoMap
```
Map<?,?> intoMap(Name keyFieldName,
 Name valueFieldName)
 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(Name, Name) instead, if your keys are non-unique

Parameters:

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

value - The value field name

Returns:

A Map containing the results

Throws:

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

InvalidResultException - if the key field returned two or more equal values from 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
```
<E> Map<?,E> intoMap(int keyFieldIndex,
 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(int, Class) instead, if your key is non-unique.

Parameters:

keyFieldIndex - 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 index 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<?,E> intoMap(String keyFieldName,
 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(String, Class) instead, if your key is non-unique.

Parameters:

keyFieldName - 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 name 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<?,E> intoMap(Name keyFieldName,
 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(Name, Class) instead, if your key is non-unique.

Parameters:

keyFieldName - 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 name 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<?,E> intoMap(int keyFieldIndex,
 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(int, Class) instead, if your key is non-unique.

Parameters:

keyFieldIndex - 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 index 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<?,E> intoMap(String keyFieldName,
 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(String, Class) instead, if your key is non-unique.

Parameters:

keyFieldName - 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 name 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<?,E> intoMap(Name keyFieldName,
 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(Name, Class) instead, if your key is non-unique.

Parameters:

keyFieldName - 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 name 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
```
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
```
Map<Record,R> intoMap(int[] keyFieldIndexes)
 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(int[]) instead, if your keys are non-unique.

Parameters:

keyFieldIndexes - 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 field indexes is not contained in fieldsRow()

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

intoMap
```
Map<Record,R> intoMap(String[] keyFieldNames)
 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(String[]) instead, if your keys are non-unique.

Parameters:

keyFieldNames - 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 field names is not contained in fieldsRow()

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

intoMap
```
Map<Record,R> intoMap(Name[] keyFieldNames)
 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(Name[]) instead, if your keys are non-unique.

Parameters:

keyFieldNames - 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 field names is not contained in fieldsRow()

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

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(int[] keyFieldIndexes,
 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(int[], Class) instead, if your keys are non-unique.

Parameters:

keyFieldIndexes - 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 field indexes 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(String[] keyFieldNames,
 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(String[], Class) instead, if your keys are non-unique.

Parameters:

keyFieldNames - 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 field names 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(Name[] keyFieldNames,
 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(Name[], Class) instead, if your keys are non-unique.

Parameters:

keyFieldNames - 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 field names 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

intoMap
```
<E> Map<List<?>,E> intoMap(int[] keyFieldIndexes,
 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(int[], Class) instead, if your keys are non-unique.

Parameters:

keyFieldIndexes - 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 field indexes 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(String[] keyFieldNames,
 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(String[], Class) instead, if your keys are non-unique.

Parameters:

keyFieldNames - 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 field names 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(Name[] keyFieldNames,
 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(Name[], Class) instead, if your keys are non-unique.

Parameters:

keyFieldNames - 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 field names 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
```
<K> Map<K,R> intoMap(Class<? extends K> keyType)
 throws MappingException,
 InvalidResultException
```
Return a Map with results grouped by the given key entity.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(Class) instead, if your keys are non-unique.

Parameters:

keyType - The key type. If this is null, the resulting map will contain at most one entry.

Returns:

A Map containing grouped results

Throws:

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

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

See Also:

DefaultRecordMapper

intoMap
```
<K,V> Map<K,V> intoMap(Class<? extends K> keyType,
 Class<? extends V> valueType)
 throws MappingException,
 InvalidResultException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(Class, Class) instead, if your keys are non-unique.

Parameters:

keyType - The key type. If this is null, the resulting map will contain at most one entry.

valueType - The value type.

Returns:

A Map containing grouped results

Throws:

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

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

See Also:

DefaultRecordMapper

intoMap
```
<K,V> Map<K,V> intoMap(Class<? extends K> keyType,
 RecordMapper<? super R,V> valueMapper)
 throws InvalidResultException,
 MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(Class, RecordMapper) instead, if your keys are non-unique.

Parameters:

keyType - The key type. If this is null, the resulting map will contain at most one entry.

valueMapper - The value mapper.

Returns:

A Map containing grouped results

Throws:

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

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

See Also:

DefaultRecordMapper

intoMap
```
<K> Map<K,R> intoMap(RecordMapper<? super R,K> keyMapper)
 throws InvalidResultException,
 MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(RecordMapper) instead, if your keys are non-unique.

Parameters:

keyMapper - The key mapper.

Returns:

A Map containing grouped results

Throws:

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

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

See Also:

DefaultRecordMapper

intoMap
```
<K,V> Map<K,V> intoMap(RecordMapper<? super R,K> keyMapper,
 Class<V> valueType)
 throws InvalidResultException,
 MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(RecordMapper, Class) instead, if your keys are non-unique.

Parameters:

keyMapper - The key mapper.

valueType - The value type.

Returns:

A Map containing grouped results

Throws:

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

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

See Also:

DefaultRecordMapper

intoMap
```
<K,V> Map<K,V> intoMap(RecordMapper<? super R,K> keyMapper,
 RecordMapper<? super R,V> valueMapper)
 throws InvalidResultException,
 MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(RecordMapper, RecordMapper) instead, if your keys are non-unique.

Parameters:

keyMapper - The key mapper.

valueMapper - The value mapper.

Returns:

A Map containing grouped results

Throws:

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

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

See Also:

DefaultRecordMapper

intoMap
```
<S extends Record> Map<S,R> intoMap(Table<S> table)
 throws IllegalArgumentException,
 InvalidResultException
```
Return a Map with the given key table 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(Table) instead, if your keys are non-unique.

Parameters:

table - The key table. Client code must assure that keys are unique in the result set. May not be null.

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
```
<E,S extends Record> Map<S,E> intoMap(Table<S> table,
 Class<? extends E> type)
 throws IllegalArgumentException,
 InvalidResultException,
 MappingException
```
Return a Map with results grouped by the given key table and mapped into the given entity type.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(Table, Class) instead, if your keys are non-unique.

Parameters:

table - The key table. Client code must assure that keys are unique in the result set. May not be null.

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,S extends Record> Map<S,E> intoMap(Table<S> table,
 RecordMapper<? super R,E> mapper)
 throws IllegalArgumentException,
 InvalidResultException,
 MappingException
```
Return a Map with results grouped by the given key table and mapped by the given mapper.
An InvalidResultException is thrown, if the keys are non-unique in the result set. Use intoGroups(Table, Class) instead, if your keys are non-unique.

Parameters:

table - The key table. Client code must assure that keys are unique in the result set. May not be null.

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
```
Map<?,Result<R>> intoGroups(int keyFieldIndex)
 throws IllegalArgumentException
```
Return a Map with one of the result's columns as key and a list of corresponding records as value.
Unlike intoMap(int), this method allows for non-unique keys in the result set.

Parameters:

keyFieldIndex - The key field index.

Returns:

A Map containing the results

Throws:

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

intoGroups
```
Map<?,Result<R>> intoGroups(String keyFieldName)
 throws IllegalArgumentException
```
Return a Map with one of the result's columns as key and a list of corresponding records as value.
Unlike intoMap(String), this method allows for non-unique keys in the result set.

Parameters:

keyFieldName - The key field name.

Returns:

A Map containing the results

Throws:

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

intoGroups
```
Map<?,Result<R>> intoGroups(Name keyFieldName)
 throws IllegalArgumentException
```
Return a Map with one of the result's columns as key and a list of corresponding records as value.
Unlike intoMap(Name), this method allows for non-unique keys in the result set.

Parameters:

keyFieldName - The key field name.

Returns:

A Map containing the results

Throws:

IllegalArgumentException - If the argument field name 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<?,List<?>> intoGroups(int keyFieldIndex,
 int valueFieldIndex)
 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(int, int), this method allows for non-unique keys in the result set.

Parameters:

keyFieldIndex - The key field index.

valueFieldIndex - The value field index.

Returns:

A Map containing the results

Throws:

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

intoGroups
```
Map<?,List<?>> intoGroups(String keyFieldName,
 String valueFieldName)
 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(String, String), this method allows for non-unique keys in the result set.

Parameters:

keyFieldName - The key field name.

valueFieldName - The value field name.

Returns:

A Map containing the results

Throws:

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

intoGroups
```
Map<?,List<?>> intoGroups(Name keyFieldName,
 Name valueFieldName)
 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(Name, Name), this method allows for non-unique keys in the result set.

Parameters:

keyFieldName - The key field name.

valueFieldName - The value field name.

Returns:

A Map containing the results

Throws:

IllegalArgumentException - If any of the argument field names 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
```
<E> Map<?,List<E>> intoGroups(int keyFieldIndex,
 Class<? extends E> type)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key and mapped into the given entity type.

Parameters:

keyFieldIndex - The key field index.

type - The entity type.

Throws:

IllegalArgumentException - If the argument field index 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<?,List<E>> intoGroups(String keyFieldName,
 Class<? extends E> type)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key and mapped into the given entity type.

Parameters:

keyFieldName - The key field name.

type - The entity type.

Throws:

IllegalArgumentException - If the argument field name 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<?,List<E>> intoGroups(Name keyFieldName,
 Class<? extends E> type)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key and mapped into the given entity type.

Parameters:

keyFieldName - The key field name.

type - The entity type.

Throws:

IllegalArgumentException - If the argument field name 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<?,List<E>> intoGroups(int keyFieldIndex,
 RecordMapper<? super R,E> mapper)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key and mapped by the given mapper.

Parameters:

keyFieldIndex - The key field index.

mapper - The mapper callback.

Throws:

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

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

intoGroups
```
<E> Map<?,List<E>> intoGroups(String keyFieldName,
 RecordMapper<? super R,E> mapper)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key and mapped by the given mapper.

Parameters:

keyFieldName - The key field name.

mapper - The mapper callback.

Throws:

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

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

intoGroups
```
<E> Map<?,List<E>> intoGroups(Name keyFieldName,
 RecordMapper<? super R,E> mapper)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key and mapped by the given mapper.

Parameters:

keyFieldName - The key field name.

mapper - The mapper callback.

Throws:

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

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

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
```
Map<Record,Result<R>> intoGroups(int[] keyFieldIndexes)
 throws IllegalArgumentException
```
Return a Map with the result grouped by the given keys.
Unlike intoMap(int[]), this method allows for non-unique keys in the result set.

Parameters:

keyFieldIndexes - 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 field indexes is not contained in fieldsRow()

intoGroups
```
Map<Record,Result<R>> intoGroups(String[] keyFieldNames)
 throws IllegalArgumentException
```
Return a Map with the result grouped by the given keys.
Unlike intoMap(String[]), this method allows for non-unique keys in the result set.

Parameters:

keyFieldNames - 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 field names is not contained in fieldsRow()

intoGroups
```
Map<Record,Result<R>> intoGroups(Name[] keyFieldNames)
 throws IllegalArgumentException
```
Return a Map with the result grouped by the given keys.
Unlike intoMap(Name[]), this method allows for non-unique keys in the result set.

Parameters:

keyFieldNames - 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 field names is not contained in fieldsRow()

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(int[] keyFieldIndexes,
 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(int[], Class), this method allows for non-unique keys in the result set.

Parameters:

keyFieldIndexes - 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 field indexes 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(String[] keyFieldNames,
 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(String[], Class), this method allows for non-unique keys in the result set.

Parameters:

keyFieldNames - 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 field names 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(Name[] keyFieldNames,
 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(Name[], Class), this method allows for non-unique keys in the result set.

Parameters:

keyFieldNames - 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 field names 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[], RecordMapper), 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

intoGroups
```
<E> Map<Record,List<E>> intoGroups(int[] keyFieldIndexes,
 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(int[], RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

keyFieldIndexes - 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 field indexes 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(String[] keyFieldNames,
 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(String[], RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

keyFieldNames - 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 field indexes 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(Name[] keyFieldNames,
 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(Name[], RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

keyFieldNames - 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 field indexes 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> Map<K,Result<R>> intoGroups(Class<? extends K> keyType)
 throws MappingException
```
Return a Map with results grouped by the given key entity.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
Unlike intoMap(Class), this method allows for non-unique keys in the result set.

Parameters:

keyType - The key type. If this is null, the resulting map will contain at most one entry.

Returns:

A Map containing grouped results

Throws:

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

See Also:

DefaultRecordMapper

intoGroups
```
<K,V> Map<K,List<V>> intoGroups(Class<? extends K> keyType,
 Class<? extends V> valueType)
 throws MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
Unlike intoMap(Class, Class), this method allows for non-unique keys in the result set.

Parameters:

keyType - The key type. If this is null, the resulting map will contain at most one entry.

valueType - The value type.

Returns:

A Map containing grouped results

Throws:

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

See Also:

DefaultRecordMapper

intoGroups
```
<K,V> Map<K,List<V>> intoGroups(Class<? extends K> keyType,
 RecordMapper<? super R,V> valueMapper)
 throws MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
Unlike intoMap(Class, RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

keyType - The key type. If this is null, the resulting map will contain at most one entry.

valueMapper - The value mapper.

Returns:

A Map containing grouped results

Throws:

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(RecordMapper<? super R,K> keyMapper)
 throws MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
Unlike intoMap(RecordMapper, RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

keyMapper - The key mapper.

Returns:

A Map containing grouped results

Throws:

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

See Also:

DefaultRecordMapper

intoGroups
```
<K,V> Map<K,List<V>> intoGroups(RecordMapper<? super R,K> keyMapper,
 Class<V> valueType)
 throws MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
Unlike intoMap(RecordMapper, Class), this method allows for non-unique keys in the result set.

Parameters:

keyMapper - The key mapper.

valueType - The value type.

Returns:

A Map containing grouped results

Throws:

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

See Also:

DefaultRecordMapper

intoGroups
```
<K,V> Map<K,List<V>> intoGroups(RecordMapper<? super R,K> keyMapper,
 RecordMapper<? super R,V> valueMapper)
 throws MappingException
```
Return a Map with results grouped by the given key entity and mapped into the given entity type.
The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.
Unlike intoMap(RecordMapper, RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

keyMapper - The key mapper.

valueMapper - The value mapper.

Returns:

A Map containing grouped results

Throws:

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

See Also:

DefaultRecordMapper

intoGroups
```
<S extends Record> Map<S,Result<R>> intoGroups(Table<S> table)
 throws IllegalArgumentException
```
Return a Map with the result grouped by the given key table.
Unlike intoMap(Table), this method allows for non-unique keys in the result set.

Parameters:

table - The key table. May not be null.

Returns:

A Map containing grouped results

Throws:

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

intoGroups
```
<E,S extends Record> Map<S,List<E>> intoGroups(Table<S> table,
 Class<? extends E> type)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key table and mapped into the given entity type.
Unlike intoMap(Table, Class), this method allows for non-unique keys in the result set.

Parameters:

table - The key table. May not be null.

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,S extends Record> Map<S,List<E>> intoGroups(Table<S> table,
 RecordMapper<? super R,E> mapper)
 throws IllegalArgumentException,
 MappingException
```
Return a Map with results grouped by the given key table and mapped into the given entity type.
Unlike intoMap(Table, RecordMapper), this method allows for non-unique keys in the result set.

Parameters:

table - The key table. May not be null.

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
```
@Deprecated
Object[][] intoArray()
```
Deprecated. - 3.6.0 - [#3879] - Use intoArrays() instead.

intoArrays
```
Object[][] intoArrays()
```
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]
 
```
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[] 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[] 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
```
Object[] intoArray(Name 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(Name)

intoArray
```
<T> T[] intoArray(Name 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(Name, Class)

intoArray
```
 U[] intoArray(Name 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(Name, 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)

intoSet
```
Set<?> intoSet(int fieldIndex)
 throws IllegalArgumentException
```
Return all values for a field index from the result.

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)

intoSet
```
<T> Set<T> intoSet(int fieldIndex,
 Class<? extends T> type)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field index from the result.

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)

intoSet
```
 Set intoSet(int fieldIndex,
 Converter<?,U> converter)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field index from the result.

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)

intoSet
```
Set<?> intoSet(String fieldName)
 throws IllegalArgumentException
```
Return all values for a field name from the result.

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)

intoSet
```
<T> Set<T> intoSet(String fieldName,
 Class<? extends T> type)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field name from the result.

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)

intoSet
```
 Set intoSet(String fieldName,
 Converter<?,U> converter)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field name from the result.

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)

intoSet
```
Set<?> intoSet(Name fieldName)
 throws IllegalArgumentException
```
Return all values for a field name from the result.

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

intoSet
```
<T> Set<T> intoSet(Name fieldName,
 Class<? extends T> type)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field name from the result.

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(Name, Class)

intoSet
```
 Set intoSet(Name fieldName,
 Converter<?,U> converter)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field name from the result.

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(Name, Converter)

intoSet
```
<T> Set<T> intoSet(Field<T> field)
 throws IllegalArgumentException
```
Return all values for a field from the result.

Returns:

The resulting values.

Throws:

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

See Also:

getValues(Field)

intoSet
```
<T> Set<T> intoSet(Field<?> field,
 Class<? extends T> type)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field from the result.

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)

intoSet
```
<T,U> Set intoSet(Field<T> field,
 Converter<? super T,U> converter)
 throws IllegalArgumentException,
 DataTypeException
```
Return all values for a field from the result.

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
```
Result<Record> into(Field<?>... fields)
```
Copy all records from this result into a new result with new records holding only a subset of the previous fields.

Parameters:

fields - The fields of the new records

Returns:

The new result

into
```
@Generated(value="This class was generated using jOOQ-tools")
<T1> Result<Record1<T1>> into(Field<T1> field1)
```
Copy all records from this result into a new result with new records holding only a subset of the previous fields.

Returns:

The new result