Module org.jooq
Package org.jooq

Interface Result<R extends Record>

Type Parameters:
R - The record type contained in this result
All Superinterfaces:
Attachable, Collection<R>, Fields, Formattable, Iterable<R>, List<R>, Serializable

public interface Result<R extends Record> extends Fields, List<R>, Attachable, Formattable
A wrapper for database results returned by SelectQuery.
Author:
Lukas Eder
See Also:
ResultQuery.getResult()
  • Method Summary

    Modifier and Type
    Method
    Description
    void
    attach​(Configuration configuration)
    Attach this result and all of its contained records to a new Configuration.
    <O extends TableRecord<O>>
    @NotNull Table<O>
    children​(ForeignKey<O,​R> key)
    Get a table expression representing the children of all of this result's records, given a foreign key.
    <X,​ A> X
    collect​(Collector<? super R,​A,​X> collector)
    Collect all records of this result.
    void
    Detach this result and all of its contained records from their current Configuration.
    <O extends TableRecord<O>>
    @NotNull Result<O>
    fetchChildren​(ForeignKey<O,​R> key)
    Fetch child records of this record, given a foreign key, as if fetching from children(ForeignKey).
    <O extends UpdatableRecord<O>>
    @NotNull Result<O>
    fetchParents​(ForeignKey<R,​O> key)
    Fetch parent records of this record, given a foreign key, as if fetching from parents(ForeignKey).
    @Nullable Object
    getValue​(int index, int fieldIndex)
    Convenience method to fetch a value at a given position in the result.
    @Nullable Object
    getValue​(int index, String fieldName)
    Convenience method to fetch a value at a given position in the result.
    <T> T
    getValue​(int index, Field<T> field)
    Convenience method to fetch a value at a given position in the result.
    @NotNull List<?>
    getValues​(int index)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(int index, Class<? extends U> type)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(int index, Converter<?,​? extends U> converter)
    Convenience method to fetch all values for a given field.
    @NotNull List<?>
    getValues​(String fieldName)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(String fieldName, Class<? extends U> type)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(String fieldName, Converter<?,​? extends U> converter)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(Field<?> field, Class<? extends U> type)
    Convenience method to fetch all values for a given field.
    <T> @NotNull List<T>
    getValues​(Field<T> field)
    Convenience method to fetch all values for a given field.
    <T,​ U> @NotNull List<U>
    getValues​(Field<T> field, Converter<? super T,​? extends U> converter)
    Convenience method to fetch all values for a given field.
    @NotNull List<?>
    getValues​(Name fieldName)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(Name fieldName, Class<? extends U> type)
    Convenience method to fetch all values for a given field.
    <U> @NotNull List<U>
    getValues​(Name fieldName, Converter<?,​? extends U> converter)
    Convenience method to fetch all values for a given field.
    @NotNull Result<R>
    intern​(int... fieldIndexes)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull Result<R>
    intern​(String... fieldNames)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull Result<R>
    intern​(Field<?>... fields)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull Result<R>
    intern​(Name... fieldNames)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    <H extends RecordHandler<? super R>>
    H
    into​(H handler)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.15.0 - [#11902] - Use Iterable.forEach(Consumer) based methods, instead.
    <E> @NotNull List<E>
    into​(Class<? extends E> type)
    Map resulting records onto a custom type.
    @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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.
    <Z extends Record>
    @NotNull Result<Z>
    into​(Table<Z> table)
    Map resulting records onto a custom record.
    @NotNull Object[]
    intoArray​(int fieldIndex)
    Return all values for a field index from the result.
    <U> @NotNull U[]
    intoArray​(int fieldIndex, Class<? extends U> type)
    Return all values for a field index from the result.
    <U> @NotNull U[]
    intoArray​(int fieldIndex, Converter<?,​? extends U> converter)
    Return all values for a field index from the result.
    @NotNull Object[]
    intoArray​(String fieldName)
    Return all values for a field name from the result.
    <U> @NotNull U[]
    intoArray​(String fieldName, Class<? extends U> type)
    Return all values for a field name from the result.
    <U> @NotNull U[]
    intoArray​(String fieldName, Converter<?,​? extends U> converter)
    Return all values for a field name from the result.
    <U> @NotNull U[]
    intoArray​(Field<?> field, Class<? extends U> type)
    Return all values for a field from the result.
    <T> @NotNull T[]
    intoArray​(Field<T> field)
    Return all values for a field from the result.
    <T,​ U> @NotNull U[]
    intoArray​(Field<T> field, Converter<? super T,​? extends U> converter)
    Return all values for a field from the result.
    @NotNull Object[]
    intoArray​(Name fieldName)
    Return all values for a field name from the result.
    <U> @NotNull U[]
    intoArray​(Name fieldName, Class<? extends U> type)
    Return all values for a field name from the result.
    <U> @NotNull U[]
    intoArray​(Name fieldName, Converter<?,​? extends U> converter)
    Return all values for a field name from the result.
    @NotNull Object[][]
    Convert this result into an array of arrays.
    @NotNull 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.
    @NotNull Map<Record,​Result<R>>
    intoGroups​(int[] keyFieldIndexes)
    Return a Map with the result grouped by the given keys.
    @NotNull Map<Record,​Result<Record>>
    intoGroups​(int[] keyFieldIndexes, int[] valueFieldIndexes)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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> @NotNull 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.
    @NotNull 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> @NotNull 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.
    <E> @NotNull 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.
    <K> @NotNull Map<K,​Result<R>>
    intoGroups​(Class<? extends K> keyType)
    Return a Map with results grouped by the given key entity.
    <K,​ V> @NotNull 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> @NotNull 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.
    @NotNull 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.
    @NotNull Map<Record,​Result<R>>
    intoGroups​(String[] keyFieldNames)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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.
    @NotNull Map<Record,​Result<Record>>
    intoGroups​(String[] keyFieldNames, String[] valueFieldNames)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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> @NotNull 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.
    @NotNull 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.
    <E> @NotNull 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.
    @NotNull Map<Record,​Result<R>>
    intoGroups​(Field<?>[] keys)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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.
    @NotNull Map<Record,​Result<Record>>
    intoGroups​(Field<?>[] keys, Field<?>[] values)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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.
    @NotNull 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.
    @NotNull Map<Record,​Result<R>>
    intoGroups​(Name[] keyFieldNames)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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.
    @NotNull Map<Record,​Result<Record>>
    intoGroups​(Name[] keyFieldNames, Name[] valueFieldNames)
    Return a Map with the result grouped by the given keys.
    <E> @NotNull 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> @NotNull 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.
    @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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.
    <S extends Record>
    @NotNull Map<S,​Result<R>>
    intoGroups​(Table<S> table)
    Return a Map with the result grouped by the given key table.
    <E,​ S extends Record>
    @NotNull 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>
    @NotNull 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.
    <S extends Record,​ T extends Record>
    @NotNull Map<S,​Result<T>>
    intoGroups​(Table<S> keyTable, Table<T> valueTable)
    Return a Map with the result grouped by the given key table.
    @NotNull Map<?,​R>
    intoMap​(int keyFieldIndex)
    Return a Map with one of the result's columns as key and the corresponding records as value.
    @NotNull Map<Record,​R>
    intoMap​(int[] keyFieldIndexes)
    Return a Map with the given keys as a map key and the corresponding record as value.
    @NotNull Map<Record,​Record>
    intoMap​(int[] keyFieldIndexes, int[] valueFieldIndexes)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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> @NotNull 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.
    @NotNull 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
    <E> @NotNull 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.
    <E> @NotNull 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.
    <K> @NotNull Map<K,​R>
    intoMap​(Class<? extends K> keyType)
    Return a Map with results grouped by the given key entity.
    <K,​ V> @NotNull 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> @NotNull 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.
    @NotNull Map<?,​R>
    intoMap​(String keyFieldName)
    Return a Map with one of the result's columns as key and the corresponding records as value.
    @NotNull Map<Record,​R>
    intoMap​(String[] keyFieldNames)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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.
    @NotNull Map<Record,​Record>
    intoMap​(String[] keyFieldNames, String[] valueFieldNames)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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> @NotNull 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.
    @NotNull 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
    <E> @NotNull 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.
    @NotNull Map<Record,​R>
    intoMap​(Field<?>[] keys)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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.
    @NotNull Map<Record,​Record>
    intoMap​(Field<?>[] keys, Field<?>[] values)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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
    <K,​ E> @NotNull 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.
    @NotNull Map<?,​R>
    intoMap​(Name keyFieldName)
    Return a Map with one of the result's columns as key and the corresponding records as value.
    @NotNull Map<Record,​R>
    intoMap​(Name[] keyFieldNames)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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.
    @NotNull Map<Record,​Record>
    intoMap​(Name[] keyFieldNames, Name[] valueFieldNames)
    Return a Map with the given keys as a map key and the corresponding record as value.
    <E> @NotNull 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> @NotNull 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.
    @NotNull 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
    <E> @NotNull 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> @NotNull 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> @NotNull 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> @NotNull 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.
    <S extends Record>
    @NotNull 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>
    @NotNull 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>
    @NotNull 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.
    <S extends Record,​ T extends Record>
    @NotNull Map<S,​T>
    intoMap​(Table<S> keyTable, Table<T> valueTable)
    Return a Map with the given key table as a map key and the corresponding record as value.
    @NotNull List<Map<String,​Object>>
    Return the generated result as a list of name/value maps.
    @NotNull ResultSet
    Generate an in-memory JDBC ResultSet containing the data of this Result.
    @NotNull Set<?>
    intoSet​(int fieldIndex)
    Return all values for a field index from the result.
    <U> @NotNull Set<U>
    intoSet​(int fieldIndex, Class<? extends U> type)
    Return all values for a field index from the result.
    <U> @NotNull Set<U>
    intoSet​(int fieldIndex, Converter<?,​? extends U> converter)
    Return all values for a field index from the result.
    @NotNull Set<?>
    intoSet​(String fieldName)
    Return all values for a field name from the result.
    <U> @NotNull Set<U>
    intoSet​(String fieldName, Class<? extends U> type)
    Return all values for a field name from the result.
    <U> @NotNull Set<U>
    intoSet​(String fieldName, Converter<?,​? extends U> converter)
    Return all values for a field name from the result.
    <U> @NotNull Set<U>
    intoSet​(Field<?> field, Class<? extends U> type)
    Return all values for a field from the result.
    <T> @NotNull Set<T>
    intoSet​(Field<T> field)
    Return all values for a field from the result.
    <T,​ U> @NotNull Set<U>
    intoSet​(Field<T> field, Converter<? super T,​? extends U> converter)
    Return all values for a field from the result.
    @NotNull Set<?>
    intoSet​(Name fieldName)
    Return all values for a field name from the result.
    <U> @NotNull Set<U>
    intoSet​(Name fieldName, Class<? extends U> type)
    Return all values for a field name from the result.
    <U> @NotNull Set<U>
    intoSet​(Name fieldName, Converter<?,​? extends U> converter)
    Return all values for a field name from the result.
    <E> @NotNull Set<E>
    intoSet​(RecordMapper<? super R,​E> mapper)
    Map results into a custom mapper callback.
    boolean
    Whether there are any records contained in this Result.
    boolean
    Whether there are any records contained in this Result.
    <E> @NotNull List<E>
    map​(RecordMapper<? super R,​E> mapper)
    Map results into a custom mapper callback.
    <O extends UpdatableRecord<O>>
    @NotNull Table<O>
    parents​(ForeignKey<R,​O> key)
    Get a table expression representing the parents of all of this result's records, given a foreign key.
    @NotNull RecordType<R>
    Get this result's record type.
    @NotNull Result<R>
    sortAsc​(int fieldIndex)
    Sort this result by one of its contained fields.
    @NotNull Result<R>
    sortAsc​(int fieldIndex, Comparator<?> comparator)
    Sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortAsc​(String fieldName)
    Sort this result by one of its contained fields.
    @NotNull Result<R>
    sortAsc​(String fieldName, Comparator<?> comparator)
    Sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortAsc​(Comparator<? super R> comparator)
    Sort this result using a comparator that can compare records.
    <T extends Comparable<? super T>>
    @NotNull Result<R>
    sortAsc​(Field<T> field)
    Sort this result by one of its contained fields.
    <T> @NotNull Result<R>
    sortAsc​(Field<T> field, Comparator<? super T> comparator)
    Sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortAsc​(Name fieldName)
    Sort this result by one of its contained fields.
    @NotNull Result<R>
    sortAsc​(Name fieldName, Comparator<?> comparator)
    Sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortDesc​(int fieldIndex)
    Reverse-sort this result by one of its contained fields.
    @NotNull Result<R>
    sortDesc​(int fieldIndex, Comparator<?> comparator)
    Reverse-sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortDesc​(String fieldName)
    Reverse-sort this result by one of its contained fields.
    @NotNull Result<R>
    sortDesc​(String fieldName, Comparator<?> comparator)
    Reverse-sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortDesc​(Comparator<? super R> comparator)
    Reverse-sort this result using a comparator that can compare records.
    <T extends Comparable<? super T>>
    @NotNull Result<R>
    sortDesc​(Field<T> field)
    Reverse-sort this result by one of its contained fields.
    <T> @NotNull Result<R>
    sortDesc​(Field<T> field, Comparator<? super T> comparator)
    Reverse-sort this result by one of its contained fields using a comparator.
    @NotNull Result<R>
    sortDesc​(Name fieldName)
    Reverse-sort this result by one of its contained fields.
    @NotNull Result<R>
    sortDesc​(Name fieldName, Comparator<?> comparator)
    Reverse-sort this result by one of its contained fields using a comparator.

    Methods inherited from interface org.jooq.Attachable

    configuration

    Methods inherited from interface java.util.Collection

    parallelStream, removeIf, stream, toArray

    Methods inherited from interface java.lang.Iterable

    forEach
  • Method Details

    • recordType

      @NotNull @NotNull RecordType<R> recordType()
      Get this result's record type.
    • 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 0-based index in the record list
      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 Fields.fieldsRow()
    • getValue

      @Nullable @Nullable 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 0-based index in the record list
      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 Fields.fieldsRow()
    • getValue

      @Nullable @Nullable 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 0-based index in the record list
      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 Fields.fieldsRow()
    • getValues

      @NotNull <T> @NotNull 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 Fields.fieldsRow()
    • getValues

      @NotNull <U> @NotNull List<U> getValues(Field<?> field, Class<? extends U> type) throws IllegalArgumentException
      Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

      The Converter that is provided by Configuration.converterProvider() will be used to convert the value to U

      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 Fields.fieldsRow()
      See Also:
      Record.get(Field, Class)
    • getValues

      @NotNull <T,​ U> @NotNull List<U> getValues(Field<T> field, Converter<? super T,​? extends 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 Fields.fieldsRow()
      See Also:
      Record.get(Field, Converter)
    • getValues

      @NotNull @NotNull List<?> getValues(int index) throws IllegalArgumentException
      Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.
      Parameters:
      index - The values' 0-based field index
      Returns:
      The values
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
    • getValues

      @NotNull <U> @NotNull List<U> getValues(int index, Class<? extends U> type) throws IllegalArgumentException, DataTypeException
      Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

      The Converter that is provided by Configuration.converterProvider() will be used to convert the value to U

      Parameters:
      index - The values' 0-based field index
      type - The type used for type conversion
      Returns:
      The values
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      Record.get(int, Class)
    • getValues

      @NotNull <U> @NotNull List<U> getValues(int index, Converter<?,​? extends 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:
      index - The values' 0-based field index
      converter - The data type converter used for type conversion
      Returns:
      The values
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      Record.get(int, Converter)
    • getValues

      @NotNull @NotNull 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 Fields.fieldsRow()
    • getValues

      @NotNull <U> @NotNull List<U> getValues(String fieldName, Class<? extends U> type) throws IllegalArgumentException, DataTypeException
      Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

      The Converter that is provided by Configuration.converterProvider() will be used to convert the value to U

      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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      Record.get(String, Class)
    • getValues

      @NotNull <U> @NotNull List<U> getValues(String fieldName, Converter<?,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      Record.get(String, Converter)
    • getValues

      @NotNull @NotNull 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 Fields.fieldsRow()
    • getValues

      @NotNull <U> @NotNull List<U> getValues(Name fieldName, Class<? extends U> type) throws IllegalArgumentException, DataTypeException
      Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.

      The Converter that is provided by Configuration.converterProvider() will be used to convert the value to U

      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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      Record.get(Name, Class)
    • getValues

      @NotNull <U> @NotNull List<U> getValues(Name fieldName, Converter<?,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      Record.get(Name, 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.
    • collect

      <X,​ A> X collect(Collector<? super R,​A,​X> collector)
      Collect all records of this result.

      This is the same as calling Stream.collect(Collector) on Collection.stream().

    • intoMaps

      @NotNull @NotNull List<Map<String,​Object>> intoMaps()
      Return the generated result as a list of name/value maps.
      Returns:
      The result.
      See Also:
      Record.intoMap()
    • intoMap

      @NotNull <K> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based 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 Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index. Client code must assure that this field is unique in the result set.
      valueFieldIndex - The 0-based value field index
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If any of the argument field indexes is not contained in Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name. Client code must assure that this field is unique in the result set.
      valueFieldName - The value field name
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If any of the argument field names is not contained in Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name. Client code must assure that this field is unique in the result set.
      valueFieldName - The value field name
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If any of the argument field names is not contained in Fields.fieldsRow()
      InvalidResultException - if the key field returned two or more equal values from the result set.
    • intoMap

      @NotNull <K,​ E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index. 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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <K,​ E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index. 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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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 Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull @NotNull Map<Record,​Record> intoMap(Field<?>[] keys, Field<?>[] values) 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[], Field[]) instead, if your keys are non-unique.

      The resulting map is iteration order preserving.

      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.
      values - The values.
      Returns:
      A Map containing the results.
      Throws:
      IllegalArgumentException - If any of the argument fields is not contained in Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull @NotNull Map<Record,​Record> intoMap(int[] keyFieldIndexes, int[] valueFieldIndexes) 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[], int[]) instead, if your keys are non-unique.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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.
      valueFieldIndexes - The values.
      Returns:
      A Map containing the results.
      Throws:
      IllegalArgumentException - If any of the argument field indexes is not contained in Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

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

      The resulting map is iteration order preserving.

      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.
      valueFieldNames - The values.
      Returns:
      A Map containing the results.
      Throws:
      IllegalArgumentException - If any of the argument field names is not contained in Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

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

      The resulting map is iteration order preserving.

      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.
      valueFieldNames - The values.
      Returns:
      A Map containing the results.
      Throws:
      IllegalArgumentException - If any of the argument field names is not contained in Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <K> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <S extends Record> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull <S extends Record,​ T extends Record> @NotNull Map<S,​T> intoMap(Table<S> keyTable, Table<T> valueTable) 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, Table) instead, if your keys are non-unique.

      The resulting map is iteration order preserving.

      Parameters:
      keyTable - The key table. Client code must assure that keys are unique in the result set. May not be null.
      valueTable - The value table. May not be null.
      Returns:
      A Map containing the results.
      Throws:
      IllegalArgumentException - If any of the argument fields is not contained in Fields.fieldsRow()
      InvalidResultException - if the keys are non-unique in the result set.
    • intoMap

      @NotNull <E,​ S extends Record> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <E,​ S extends Record> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.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

      @NotNull <K> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index.
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If the argument field index is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name.
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If the argument field name is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name.
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If the argument field name is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index.
      valueFieldIndex - The 0-based value field index.
      Returns:
      A Map containing the results
      Throws:
      IllegalArgumentException - If any of the argument field indexes is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull <K,​ E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index.
      type - The entity type.
      Throws:
      IllegalArgumentException - If the argument field index is not contained in Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name.
      type - The entity type.
      Throws:
      IllegalArgumentException - If the argument field name is not contained in Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name.
      type - The entity type.
      Throws:
      IllegalArgumentException - If the argument field name is not contained in Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <K,​ E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
    • intoGroups

      @NotNull <E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndex - The 0-based key field index.
      mapper - The mapper callback.
      Throws:
      IllegalArgumentException - If the argument field index is not contained in Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
    • intoGroups

      @NotNull <E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name.
      mapper - The mapper callback.
      Throws:
      IllegalArgumentException - If the argument field name is not contained in Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
    • intoGroups

      @NotNull <E> @NotNull 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.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldName - The key field name.
      mapper - The mapper callback.
      Throws:
      IllegalArgumentException - If the argument field name is not contained in Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull Map<Record,​Result<Record>> intoGroups(Field<?>[] keys, Field<?>[] values) throws IllegalArgumentException
      Return a Map with the result grouped by the given keys.

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

      The resulting map is iteration order preserving.

      Parameters:
      keys - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
      values - The values.
      Returns:
      A Map containing grouped results
      Throws:
      IllegalArgumentException - If any of the argument fields is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull Map<Record,​Result<Record>> intoGroups(int[] keyFieldIndexes, int[] valueFieldIndexes) throws IllegalArgumentException
      Return a Map with the result grouped by the given keys.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. If this is null or an empty array, the resulting map will contain at most one entry.
      valueFieldIndexes - The 0-based value field indexes.
      Returns:
      A Map containing grouped results
      Throws:
      IllegalArgumentException - If any of the argument field indexes is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull Map<Record,​Result<Record>> intoGroups(String[] keyFieldNames, String[] valueFieldNames) throws IllegalArgumentException
      Return a Map with the result grouped by the given keys.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldNames - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
      valueFieldNames - The values.
      Returns:
      A Map containing grouped results
      Throws:
      IllegalArgumentException - If any of the argument field names is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull @NotNull Map<Record,​Result<Record>> intoGroups(Name[] keyFieldNames, Name[] valueFieldNames) throws IllegalArgumentException
      Return a Map with the result grouped by the given keys.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldNames - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
      valueFieldNames - The values.
      Returns:
      A Map containing grouped results
      Throws:
      IllegalArgumentException - If any of the argument field names is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      Parameters:
      keyFieldIndexes - The 0-based key field indexes. 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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <K> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <K,​ V> @NotNull 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.

      The resulting map is iteration order preserving.

      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

      @NotNull <S extends Record> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
    • intoGroups

      @NotNull <S extends Record,​ T extends Record> @NotNull Map<S,​Result<T>> intoGroups(Table<S> keyTable, Table<T> valueTable) throws IllegalArgumentException
      Return a Map with the result grouped by the given key table.

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

      The resulting map is iteration order preserving.

      Parameters:
      keyTable - The key table. May not be null.
      valueTable - The value table. May not be null.
      Returns:
      A Map containing grouped results
      Throws:
      IllegalArgumentException - If any of the argument fields is not contained in Fields.fieldsRow()
    • intoGroups

      @NotNull <E,​ S extends Record> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoGroups

      @NotNull <E,​ S extends Record> @NotNull 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.

      The resulting map is iteration order preserving.

      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 Fields.fieldsRow()
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      DefaultRecordMapper
    • intoArrays

      @NotNull @NotNull 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

      @NotNull @NotNull 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]
      Parameters:
      fieldIndex - The 0-based field index
      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 Fields.fieldsRow()
      See Also:
      getValues(int)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(int fieldIndex, Class<? extends U> type) throws IllegalArgumentException, DataTypeException
      Return all values for a field index from the result.

      You can access data like this

      result.intoArray(fieldIndex)[recordIndex]
      Parameters:
      fieldIndex - The 0-based field index
      Returns:
      The resulting values.
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(int, Class)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(int fieldIndex, Converter<?,​? extends 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]
      Parameters:
      fieldIndex - The 0-based field index
      Returns:
      The resulting values.
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(int, Converter)
    • intoArray

      @NotNull @NotNull 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 Fields.fieldsRow()
      See Also:
      getValues(String)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(String fieldName, Class<? extends U> 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(String, Class)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(String fieldName, Converter<?,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(String, Converter)
    • intoArray

      @NotNull @NotNull 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 Fields.fieldsRow()
      See Also:
      getValues(Name)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(Name fieldName, Class<? extends U> 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Name, Class)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(Name fieldName, Converter<?,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Name, Converter)
    • intoArray

      @NotNull <T> @NotNull 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 Fields.fieldsRow()
      See Also:
      getValues(Field)
    • intoArray

      @NotNull <U> @NotNull U[] intoArray(Field<?> field, Class<? extends U> 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Field, Class)
    • intoArray

      @NotNull <T,​ U> @NotNull U[] intoArray(Field<T> field, Converter<? super T,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Field, Converter)
    • intoSet

      @NotNull <E> @NotNull Set<E> intoSet(RecordMapper<? super R,​E> mapper)
      Map results into a custom mapper callback.
      Parameters:
      mapper - The mapper callback
      Returns:
      The custom mapped records
    • intoSet

      @NotNull @NotNull Set<?> intoSet(int fieldIndex) throws IllegalArgumentException
      Return all values for a field index from the result.
      Parameters:
      fieldIndex - The 0-based field index
      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 Fields.fieldsRow()
      See Also:
      getValues(int)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(int fieldIndex, Class<? extends U> type) throws IllegalArgumentException, DataTypeException
      Return all values for a field index from the result.
      Parameters:
      fieldIndex - The 0-based field index
      Returns:
      The resulting values.
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(int, Class)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(int fieldIndex, Converter<?,​? extends U> converter) throws IllegalArgumentException, DataTypeException
      Return all values for a field index from the result.
      Parameters:
      fieldIndex - The 0-based field index
      Returns:
      The resulting values.
      Throws:
      IllegalArgumentException - If the argument fieldIndex is not contained in Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(int, Converter)
    • intoSet

      @NotNull @NotNull 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 Fields.fieldsRow()
      See Also:
      getValues(String)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(String fieldName, Class<? extends U> 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(String, Class)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(String fieldName, Converter<?,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(String, Converter)
    • intoSet

      @NotNull @NotNull 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 Fields.fieldsRow()
      See Also:
      getValues(Name)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(Name fieldName, Class<? extends U> 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Name, Class)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(Name fieldName, Converter<?,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Name, Converter)
    • intoSet

      @NotNull <T> @NotNull 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 Fields.fieldsRow()
      See Also:
      getValues(Field)
    • intoSet

      @NotNull <U> @NotNull Set<U> intoSet(Field<?> field, Class<? extends U> 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Field, Class)
    • intoSet

      @NotNull <T,​ U> @NotNull Set<U> intoSet(Field<T> field, Converter<? super T,​? extends 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 Fields.fieldsRow()
      DataTypeException - wrapping any data type conversion exception that might have occurred
      See Also:
      getValues(Field, Converter)
    • into

      @NotNull @NotNull 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

      @NotNull <T1> @NotNull 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
    • into

      @NotNull <T1,​ T2> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16,​ T17> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16,​ T17,​ T18> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16,​ T17,​ T18,​ T19> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16,​ T17,​ T18,​ T19,​ T20> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16,​ T17,​ T18,​ T19,​ T20,​ T21> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <T1,​ T2,​ T3,​ T4,​ T5,​ T6,​ T7,​ T8,​ T9,​ T10,​ T11,​ T12,​ T13,​ T14,​ T15,​ T16,​ T17,​ T18,​ T19,​ T20,​ T21,​ T22> @NotNull 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.
      Returns:
      The new result
    • into

      @NotNull <E> @NotNull List<E> into(Class<? extends E> type) throws MappingException
      Map resulting records onto a custom type.

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

      Type Parameters:
      E - The generic entity type.
      Parameters:
      type - The entity type.
      Throws:
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      Record.into(Class), DefaultRecordMapper
    • into

      @NotNull <Z extends Record> @NotNull Result<Z> into(Table<Z> table) throws MappingException
      Map resulting records onto a custom record.

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

      Type Parameters:
      Z - The generic table record type.
      Parameters:
      table - The table type.
      Throws:
      MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
      See Also:
      Record.into(Table)
    • into

      @Deprecated(forRemoval=true, since="3.15") @NotNull <H extends RecordHandler<? super R>> H into(H handler)
      Deprecated, for removal: This API element is subject to removal in a future version.
      - 3.15.0 - [#11902] - Use Iterable.forEach(Consumer) based methods, instead.
      Map results into a custom handler callback.
      Parameters:
      handler - The handler callback
      Returns:
      Convenience result, returning the parameter handler itself
    • intoResultSet

      @NotNull @NotNull ResultSet intoResultSet()
      Generate an in-memory JDBC ResultSet containing the data of this Result.

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

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

      Returns:
      A wrapper JDBC ResultSet
    • map

      @NotNull <E> @NotNull List<E> map(RecordMapper<? super R,​E> mapper)
      Map results into a custom mapper callback.
      Parameters:
      mapper - The mapper callback
      Returns:
      The custom mapped records
    • sortAsc

      @NotNull <T extends Comparable<? super T>> @NotNull Result<R> sortAsc(Field<T> field) throws IllegalArgumentException
      Sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      field - The sort field
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull <T extends Comparable<? super T>> @NotNull Result<R> sortDesc(Field<T> field) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      field - The sort field
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(int fieldIndex) throws IllegalArgumentException
      Sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      fieldIndex - The 0-based sort field index
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(int fieldIndex) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      fieldIndex - The 0-based sort field index
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(String fieldName) throws IllegalArgumentException
      Sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      fieldName - The sort field name
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(String fieldName) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      fieldName - The sort field name
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(Name fieldName) throws IllegalArgumentException
      Sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      fieldName - The sort field name
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(Name fieldName) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields.

      nulls are sorted last by this method.

      Parameters:
      fieldName - The sort field name
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull <T> @NotNull Result<R> sortAsc(Field<T> field, Comparator<? super T> comparator) throws IllegalArgumentException
      Sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      field - The sort field
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull <T> @NotNull Result<R> sortDesc(Field<T> field, Comparator<? super T> comparator) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      field - The sort field
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(int fieldIndex, Comparator<?> comparator) throws IllegalArgumentException
      Sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      fieldIndex - The 0-based sort field index
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(int fieldIndex, Comparator<?> comparator) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      fieldIndex - The 0-based sort field index
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(String fieldName, Comparator<?> comparator) throws IllegalArgumentException
      Sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      fieldName - The sort field name
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(String fieldName, Comparator<?> comparator) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      fieldName - The sort field name
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(Name fieldName, Comparator<?> comparator) throws IllegalArgumentException
      Sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      fieldName - The sort field name
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(Name fieldName, Comparator<?> comparator) throws IllegalArgumentException
      Reverse-sort this result by one of its contained fields using a comparator.

      null sorting must be handled by the supplied comparator.

      Parameters:
      fieldName - The sort field name
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
      Throws:
      IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
    • sortAsc

      @NotNull @NotNull Result<R> sortAsc(Comparator<? super R> comparator)
      Sort this result using a comparator that can compare records.
      Parameters:
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
    • sortDesc

      @NotNull @NotNull Result<R> sortDesc(Comparator<? super R> comparator)
      Reverse-sort this result using a comparator that can compare records.
      Parameters:
      comparator - The comparator used to sort this result.
      Returns:
      The result itself
    • intern

      @NotNull @Deprecated(forRemoval=true, since="3.10") @NotNull Result<R> intern(Field<?>... fields)
      Deprecated, for removal: This API element is subject to removal in a future version.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Specify a set of fields whose values should be interned.

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

      Parameters:
      fields - The fields whose values should be interned
      Returns:
      The same result
      See Also:
      intern(Field...), String.intern()
    • intern

      @NotNull @Deprecated(forRemoval=true, since="3.10") @NotNull Result<R> intern(int... fieldIndexes)
      Deprecated, for removal: This API element is subject to removal in a future version.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Specify a set of field indexes whose values should be interned.

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

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

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

      Parameters:
      fieldIndexes - The 0-based field indexes whose values should be interned
      Returns:
      The same result
      See Also:
      intern(Field...), String.intern()
    • intern

      @NotNull @Deprecated(forRemoval=true, since="3.10") @NotNull Result<R> intern(String... fieldNames)
      Deprecated, for removal: This API element is subject to removal in a future version.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Specify a set of field names whose values should be interned.

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

      Parameters:
      fieldNames - The field names whose values should be interned
      Returns:
      The same result
      See Also:
      intern(Field...), String.intern()
    • intern

      @NotNull @Deprecated(forRemoval=true, since="3.10") @NotNull Result<R> intern(Name... fieldNames)
      Deprecated, for removal: This API element is subject to removal in a future version.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Specify a set of field names whose values should be interned.

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

      Parameters:
      fieldNames - The field names whose values should be interned
      Returns:
      The same result
      See Also:
      intern(Field...), String.intern()
    • fetchParents

      @NotNull <O extends UpdatableRecord<O>> @NotNull Result<O> fetchParents(ForeignKey<R,​O> key) throws DataAccessException
      Fetch parent records of this record, given a foreign key, as if fetching from parents(ForeignKey).
      Throws:
      DataAccessException - if something went wrong executing the query.
      See Also:
      ForeignKey.fetchParent(Record), ForeignKey.fetchParents(java.util.Collection), ForeignKey.fetchParents(Record...)
    • fetchChildren

      @NotNull <O extends TableRecord<O>> @NotNull Result<O> fetchChildren(ForeignKey<O,​R> key) throws DataAccessException
      Fetch child records of this record, given a foreign key, as if fetching from children(ForeignKey).
      Throws:
      DataAccessException - if something went wrong executing the query.
      See Also:
      ForeignKey.fetchChildren(java.util.Collection), ForeignKey.fetchChildren(Record), ForeignKey.fetchChildren(Record...)
    • parents

      @NotNull <O extends UpdatableRecord<O>> @NotNull Table<O> parents(ForeignKey<R,​O> key)
      Get a table expression representing the parents of all of this result's records, given a foreign key.
    • children

      @NotNull <O extends TableRecord<O>> @NotNull Table<O> children(ForeignKey<O,​R> key)
      Get a table expression representing the children of all of this result's records, given a foreign key.
    • attach

      void attach(Configuration configuration)
      Attach this result and all of its contained records to a new Configuration.
      Specified by:
      attach in interface Attachable
      Parameters:
      configuration - A configuration or null, if you wish to detach this Attachable from its previous configuration.
    • detach

      void detach()
      Detach this result and all of its contained records from their current Configuration.

      This is the same as calling attach(null).

      Specified by:
      detach in interface Attachable