Package org.jooq

Interface Result<R extends Record>

    • Method Summary

      All Methods Instance Methods Abstract Methods Deprecated Methods 
      Modifier and Type Method Description
      void attach​(Configuration configuration)
      Attach this result and all of its contained records to a new Configuration.
      void detach()
      Detach this result and all of its contained records from their current Configuration.
      <O extends TableRecord<O>>
      Result<O>      		 fetchChildren​(ForeignKey<O,​R> key)
      Fetch child records of this record, given a foreign key.
      <O extends UpdatableRecord<O>>
      Result<O>      		 fetchParents​(ForeignKey<R,​O> key)
      Fetch parent records of this record, given a foreign key.
      Field<?> field​(int index)
      Get a specific field from this Result.
      <T> Field<T> field​(int index, java.lang.Class<T> type)
      Get a specific field from this Result, coerced to type.
      <T> Field<T> field​(int index, DataType<T> dataType)
      Get a specific field from this Result, coerced to dataType.
      Field<?> field​(java.lang.String name)
      Get a specific field from this Result.
      <T> Field<T> field​(java.lang.String name, java.lang.Class<T> type)
      Get a specific field from this Result, coerced to type.
      <T> Field<T> field​(java.lang.String name, DataType<T> dataType)
      Get a specific field from this Result, coerced to dataType.
      <T> Field<T> field​(Field<T> field)
      Get a specific field from this Result.
      Field<?> field​(Name name)
      Get a specific field from this Result.
      <T> Field<T> field​(Name name, java.lang.Class<T> type)
      Get a specific field from this Result, coerced to type.
      <T> Field<T> field​(Name name, DataType<T> dataType)
      Get a specific field from this Result, coerced to dataType.
      Field<?>[] fields()
      Get all fields from this Result.
      Field<?>[] fields​(int... fieldIndexes)
      Get all fields from this Result, providing some field indexes.
      Field<?>[] fields​(java.lang.String... fieldNames)
      Get all fields from this Result, providing some field names.
      Field<?>[] fields​(Field<?>... fields)
      Get all fields from this Result, providing some fields.
      Field<?>[] fields​(Name... fieldNames)
      Get all fields from this Result, providing some field names.
      Row fieldsRow()
      Get this result's fields as a Row.
      java.lang.Object getValue​(int index, int fieldIndex)
      Convenience method to fetch a value at a given position in the result.
      java.lang.Object getValue​(int index, int fieldIndex, java.lang.Object defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      java.lang.Object getValue​(int index, java.lang.String fieldName)
      Convenience method to fetch a value at a given position in the result.
      java.lang.Object getValue​(int index, java.lang.String fieldName, java.lang.Object defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      <T> T getValue​(int index, Field<T> field)
      Convenience method to fetch a value at a given position in the result.
      <T> T getValue​(int index, Field<T> field, T defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      java.util.List<?> getValues​(int fieldIndex)
      Convenience method to fetch all values for a given field.
      <T> java.util.List<T> getValues​(int fieldIndex, java.lang.Class<? extends T> type)
      Convenience method to fetch all values for a given field.
      <U> java.util.List<U> getValues​(int fieldIndex, Converter<?,​? extends U> converter)
      Convenience method to fetch all values for a given field.
      java.util.List<?> getValues​(java.lang.String fieldName)
      Convenience method to fetch all values for a given field.
      <T> java.util.List<T> getValues​(java.lang.String fieldName, java.lang.Class<? extends T> type)
      Convenience method to fetch all values for a given field.
      <U> java.util.List<U> getValues​(java.lang.String fieldName, Converter<?,​? extends U> converter)
      Convenience method to fetch all values for a given field.
      <T> java.util.List<T> getValues​(Field<?> field, java.lang.Class<? extends T> type)
      Convenience method to fetch all values for a given field.
      <T> java.util.List<T> getValues​(Field<T> field)
      Convenience method to fetch all values for a given field.
      <T,​U>
      java.util.List<U>      		 getValues​(Field<T> field, Converter<? super T,​? extends U> converter)
      Convenience method to fetch all values for a given field.
      java.util.List<?> getValues​(Name fieldName)
      Convenience method to fetch all values for a given field.
      <T> java.util.List<T> getValues​(Name fieldName, java.lang.Class<? extends T> type)
      Convenience method to fetch all values for a given field.
      <U> java.util.List<U> getValues​(Name fieldName, Converter<?,​? extends U> converter)
      Convenience method to fetch all values for a given field.
      int indexOf​(java.lang.String fieldName)
      Get a field's index from this result.
      int indexOf​(Field<?> field)
      Get a field's index from this result.
      int indexOf​(Name fieldName)
      Get a field's index from this result.
      Result<R> intern​(int... fieldIndexes)
      Deprecated.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Result<R> intern​(java.lang.String... fieldNames)
      Deprecated.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Result<R> intern​(Field<?>... fields)
      Deprecated.
      - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
      Result<R> intern​(Name... fieldNames)
      Deprecated.
      - 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)
      Map results into a custom handler callback.
      <E> java.util.List<E> into​(java.lang.Class<? extends E> type)
      Map resulting records onto a custom type.
      Result<Record> into​(Field<?>... fields)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1> Result<Record1<T1>> into​(Field<T1> field1)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2>
      Result<Record2<T1,​T2>>      		 into​(Field<T1> field1, Field<T2> field2)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3>
      Result<Record3<T1,​T2,​T3>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4>
      Result<Record4<T1,​T2,​T3,​T4>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5>
      Result<Record5<T1,​T2,​T3,​T4,​T5>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6>
      Result<Record6<T1,​T2,​T3,​T4,​T5,​T6>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7>
      Result<Record7<T1,​T2,​T3,​T4,​T5,​T6,​T7>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>
      Result<Record8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>
      Result<Record9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>
      Result<Record10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>
      Result<Record11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>
      Result<Record12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>
      Result<Record13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>
      Result<Record14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>
      Result<Record15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>
      Result<Record16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17>
      Result<Record17<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18>
      Result<Record18<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19>
      Result<Record19<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20>
      Result<Record20<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21>
      Result<Record21<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22>
      Result<Record22<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22>>      		 into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22)
      Copy all records from this result into a new result with new records holding only a subset of the previous fields.
      <Z extends Record>
      Result<Z>      		 into​(Table<Z> table)
      Map resulting records onto a custom record.
      java.lang.Object[][] intoArray()
      Deprecated.
      - 3.6.0 - [#3879] - Use intoArrays() instead.
      java.lang.Object[] intoArray​(int fieldIndex)
      Return all values for a field index from the result.
      <T> T[] intoArray​(int fieldIndex, java.lang.Class<? extends T> type)
      Return all values for a field index from the result.
      <U> U[] intoArray​(int fieldIndex, Converter<?,​? extends U> converter)
      Return all values for a field index from the result.
      java.lang.Object[] intoArray​(java.lang.String fieldName)
      Return all values for a field name from the result.
      <T> T[] intoArray​(java.lang.String fieldName, java.lang.Class<? extends T> type)
      Return all values for a field name from the result.
      <U> U[] intoArray​(java.lang.String fieldName, Converter<?,​? extends U> converter)
      Return all values for a field name from the result.
      <T> T[] intoArray​(Field<?> field, java.lang.Class<? extends T> type)
      Return all values for a field from the result.
      <T> T[] intoArray​(Field<T> field)
      Return all values for a field from the result.
      <T,​U>
      U[]      		 intoArray​(Field<T> field, Converter<? super T,​? extends U> converter)
      Return all values for a field from the result.
      java.lang.Object[] intoArray​(Name fieldName)
      Return all values for a field name from the result.
      <T> T[] intoArray​(Name fieldName, java.lang.Class<? extends T> type)
      Return all values for a field name from the result.
      <U> U[] intoArray​(Name fieldName, Converter<?,​? extends U> converter)
      Return all values for a field name from the result.
      java.lang.Object[][] intoArrays()
      Convert this result into an array of arrays.
      java.util.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.
      java.util.Map<Record,​Result<R>> intoGroups​(int[] keyFieldIndexes)
      Return a Map with the result grouped by the given keys.
      java.util.Map<Record,​Result<Record>> intoGroups​(int[] keyFieldIndexes, int[] valueFieldIndexes)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(int[] keyFieldIndexes, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      <E> java.util.Map<Record,​java.util.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.
      java.util.Map<?,​java.util.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> java.util.Map<?,​java.util.List<E>> intoGroups​(int keyFieldIndex, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      <E> java.util.Map<?,​java.util.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> java.util.Map<K,​Result<R>> intoGroups​(java.lang.Class<? extends K> keyType)
      Return a Map with results grouped by the given key entity.
      <K,​V>
      java.util.Map<K,​java.util.List<V>>      		 intoGroups​(java.lang.Class<? extends K> keyType, java.lang.Class<? extends V> valueType)
      Return a Map with results grouped by the given key entity and mapped into the given entity type.
      <K,​V>
      java.util.Map<K,​java.util.List<V>>      		 intoGroups​(java.lang.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.
      java.util.Map<?,​Result<R>> intoGroups​(java.lang.String keyFieldName)
      Return a Map with one of the result's columns as key and a list of corresponding records as value.
      java.util.Map<Record,​Result<R>> intoGroups​(java.lang.String[] keyFieldNames)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(java.lang.String[] keyFieldNames, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      java.util.Map<Record,​Result<Record>> intoGroups​(java.lang.String[] keyFieldNames, java.lang.String[] valueFieldNames)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(java.lang.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> java.util.Map<?,​java.util.List<E>> intoGroups​(java.lang.String keyFieldName, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      java.util.Map<?,​java.util.List<?>> intoGroups​(java.lang.String keyFieldName, java.lang.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> java.util.Map<?,​java.util.List<E>> intoGroups​(java.lang.String keyFieldName, RecordMapper<? super R,​E> mapper)
      Return a Map with results grouped by the given key and mapped by the given mapper.
      java.util.Map<Record,​Result<R>> intoGroups​(Field<?>[] keys)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(Field<?>[] keys, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      java.util.Map<Record,​Result<Record>> intoGroups​(Field<?>[] keys, Field<?>[] values)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.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> java.util.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>
      java.util.Map<K,​java.util.List<E>>      		 intoGroups​(Field<K> key, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      <K,​V>
      java.util.Map<K,​java.util.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>
      java.util.Map<K,​java.util.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.
      java.util.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.
      java.util.Map<Record,​Result<R>> intoGroups​(Name[] keyFieldNames)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(Name[] keyFieldNames, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      java.util.Map<Record,​Result<Record>> intoGroups​(Name[] keyFieldNames, Name[] valueFieldNames)
      Return a Map with the result grouped by the given keys.
      <E> java.util.Map<Record,​java.util.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> java.util.Map<?,​java.util.List<E>> intoGroups​(Name keyFieldName, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      java.util.Map<?,​java.util.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> java.util.Map<?,​java.util.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> java.util.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>
      java.util.Map<K,​java.util.List<V>>      		 intoGroups​(RecordMapper<? super R,​K> keyMapper, java.lang.Class<V> valueType)
      Return a Map with results grouped by the given key entity and mapped into the given entity type.
      <K,​V>
      java.util.Map<K,​java.util.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>
      java.util.Map<S,​Result<R>>      		 intoGroups​(Table<S> table)
      Return a Map with the result grouped by the given key table.
      <E,​S extends Record>
      java.util.Map<S,​java.util.List<E>>      		 intoGroups​(Table<S> table, java.lang.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>
      java.util.Map<S,​java.util.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>
      java.util.Map<S,​Result<T>>      		 intoGroups​(Table<S> keyTable, Table<T> valueTable)
      Return a Map with the result grouped by the given key table.
      java.util.Map<?,​R> intoMap​(int keyFieldIndex)
      Return a Map with one of the result's columns as key and the corresponding records as value.
      java.util.Map<Record,​R> intoMap​(int[] keyFieldIndexes)
      Return a Map with the given keys as a map key and the corresponding record as value.
      java.util.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> java.util.Map<java.util.List<?>,​E> intoMap​(int[] keyFieldIndexes, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      <E> java.util.Map<java.util.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.
      java.util.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> java.util.Map<?,​E> intoMap​(int keyFieldIndex, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      <E> java.util.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> java.util.Map<K,​R> intoMap​(java.lang.Class<? extends K> keyType)
      Return a Map with results grouped by the given key entity.
      <K,​V>
      java.util.Map<K,​V>      		 intoMap​(java.lang.Class<? extends K> keyType, java.lang.Class<? extends V> valueType)
      Return a Map with results grouped by the given key entity and mapped into the given entity type.
      <K,​V>
      java.util.Map<K,​V>      		 intoMap​(java.lang.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.
      java.util.Map<?,​R> intoMap​(java.lang.String keyFieldName)
      Return a Map with one of the result's columns as key and the corresponding records as value.
      java.util.Map<Record,​R> intoMap​(java.lang.String[] keyFieldNames)
      Return a Map with the given keys as a map key and the corresponding record as value.
      <E> java.util.Map<java.util.List<?>,​E> intoMap​(java.lang.String[] keyFieldNames, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      java.util.Map<Record,​Record> intoMap​(java.lang.String[] keyFieldNames, java.lang.String[] valueFieldNames)
      Return a Map with the given keys as a map key and the corresponding record as value.
      <E> java.util.Map<java.util.List<?>,​E> intoMap​(java.lang.String[] keyFieldNames, RecordMapper<? super R,​E> mapper)
      Return a Map with results grouped by the given keys and mapped by the given mapper.
      <E> java.util.Map<?,​E> intoMap​(java.lang.String keyFieldName, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      java.util.Map<?,​?> intoMap​(java.lang.String keyFieldName, java.lang.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> java.util.Map<?,​E> intoMap​(java.lang.String keyFieldName, RecordMapper<? super R,​E> mapper)
      Return a Map with results grouped by the given key and mapped by the given mapper.
      java.util.Map<Record,​R> intoMap​(Field<?>[] keys)
      Return a Map with the given keys as a map key and the corresponding record as value.
      <E> java.util.Map<java.util.List<?>,​E> intoMap​(Field<?>[] keys, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      java.util.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> java.util.Map<java.util.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> java.util.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>
      java.util.Map<K,​E>      		 intoMap​(Field<K> key, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      <K,​V>
      java.util.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>
      java.util.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.
      java.util.Map<?,​R> intoMap​(Name keyFieldName)
      Return a Map with one of the result's columns as key and the corresponding records as value.
      java.util.Map<Record,​R> intoMap​(Name[] keyFieldNames)
      Return a Map with the given keys as a map key and the corresponding record as value.
      <E> java.util.Map<java.util.List<?>,​E> intoMap​(Name[] keyFieldNames, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given keys and mapped into the given entity type.
      java.util.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> java.util.Map<java.util.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> java.util.Map<?,​E> intoMap​(Name keyFieldName, java.lang.Class<? extends E> type)
      Return a Map with results grouped by the given key and mapped into the given entity type.
      java.util.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> java.util.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> java.util.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>
      java.util.Map<K,​V>      		 intoMap​(RecordMapper<? super R,​K> keyMapper, java.lang.Class<V> valueType)
      Return a Map with results grouped by the given key entity and mapped into the given entity type.
      <K,​V>
      java.util.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>
      java.util.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>
      java.util.Map<S,​E>      		 intoMap​(Table<S> table, java.lang.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>
      java.util.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>
      java.util.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.
      java.util.List<java.util.Map<java.lang.String,​java.lang.Object>> intoMaps()
      Return the generated result as a list of name/value maps.
      java.sql.ResultSet intoResultSet()
      Generate an in-memory JDBC ResultSet containing the data of this Result.
      java.util.Set<?> intoSet​(int fieldIndex)
      Return all values for a field index from the result.
      <T> java.util.Set<T> intoSet​(int fieldIndex, java.lang.Class<? extends T> type)
      Return all values for a field index from the result.
      <U> java.util.Set<U> intoSet​(int fieldIndex, Converter<?,​? extends U> converter)
      Return all values for a field index from the result.
      java.util.Set<?> intoSet​(java.lang.String fieldName)
      Return all values for a field name from the result.
      <T> java.util.Set<T> intoSet​(java.lang.String fieldName, java.lang.Class<? extends T> type)
      Return all values for a field name from the result.
      <U> java.util.Set<U> intoSet​(java.lang.String fieldName, Converter<?,​? extends U> converter)
      Return all values for a field name from the result.
      <T> java.util.Set<T> intoSet​(Field<?> field, java.lang.Class<? extends T> type)
      Return all values for a field from the result.
      <T> java.util.Set<T> intoSet​(Field<T> field)
      Return all values for a field from the result.
      <T,​U>
      java.util.Set<U>      		 intoSet​(Field<T> field, Converter<? super T,​? extends U> converter)
      Return all values for a field from the result.
      java.util.Set<?> intoSet​(Name fieldName)
      Return all values for a field name from the result.
      <T> java.util.Set<T> intoSet​(Name fieldName, java.lang.Class<? extends T> type)
      Return all values for a field name from the result.
      <U> java.util.Set<U> intoSet​(Name fieldName, Converter<?,​? extends U> converter)
      Return all values for a field name from the result.
      <E> java.util.Set<E> intoSet​(RecordMapper<? super R,​E> mapper)
      Map results into a custom mapper callback.
      boolean isEmpty()
      Whether there are any records contained in this Result.
      boolean isNotEmpty()
      Whether there are any records contained in this Result.
      <E> java.util.List<E> map​(RecordMapper<? super R,​E> mapper)
      Map results into a custom mapper callback.
      RecordType<R> recordType()
      Get this result's record type.
      Result<R> sortAsc​(int fieldIndex)
      Sort this result by one of its contained fields.
      Result<R> sortAsc​(int fieldIndex, java.util.Comparator<?> comparator)
      Sort this result by one of its contained fields using a comparator.
      Result<R> sortAsc​(java.lang.String fieldName)
      Sort this result by one of its contained fields.
      Result<R> sortAsc​(java.lang.String fieldName, java.util.Comparator<?> comparator)
      Sort this result by one of its contained fields using a comparator.
      Result<R> sortAsc​(java.util.Comparator<? super R> comparator)
      Sort this result using a comparator that can compare records.
      <T extends java.lang.Comparable<? super T>>
      Result<R>      		 sortAsc​(Field<T> field)
      Sort this result by one of its contained fields.
      <T> Result<R> sortAsc​(Field<T> field, java.util.Comparator<? super T> comparator)
      Sort this result by one of its contained fields using a comparator.
      Result<R> sortAsc​(Name fieldName)
      Sort this result by one of its contained fields.
      Result<R> sortAsc​(Name fieldName, java.util.Comparator<?> comparator)
      Sort this result by one of its contained fields using a comparator.
      Result<R> sortDesc​(int fieldIndex)
      Reverse-sort this result by one of its contained fields.
      Result<R> sortDesc​(int fieldIndex, java.util.Comparator<?> comparator)
      Reverse-sort this result by one of its contained fields using a comparator.
      Result<R> sortDesc​(java.lang.String fieldName)
      Reverse-sort this result by one of its contained fields.
      Result<R> sortDesc​(java.lang.String fieldName, java.util.Comparator<?> comparator)
      Reverse-sort this result by one of its contained fields using a comparator.
      Result<R> sortDesc​(java.util.Comparator<? super R> comparator)
      Reverse-sort this result using a comparator that can compare records.
      <T extends java.lang.Comparable<? super T>>
      Result<R>      		 sortDesc​(Field<T> field)
      Reverse-sort this result by one of its contained fields.
      <T> Result<R> sortDesc​(Field<T> field, java.util.Comparator<? super T> comparator)
      Reverse-sort this result by one of its contained fields using a comparator.
      Result<R> sortDesc​(Name fieldName)
      Reverse-sort this result by one of its contained fields.
      Result<R> sortDesc​(Name fieldName, java.util.Comparator<?> comparator)
      Reverse-sort this result by one of its contained fields using a comparator.

      • Methods inherited from interface java.util.Collection

        parallelStream, removeIf, stream, toArray

      • Methods inherited from interface java.lang.Iterable

        forEach

      • Methods inherited from interface java.util.List

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

    • Method Detail

      • recordType

        RecordType<R> recordType()
        Get this result's record type.

      • fieldsRow

        Row fieldsRow()
        Get this result's fields as a Row.

      • field

        <T> Field<T> field​(Field<T> field)
        Get a specific field from this Result.

        This will return:

        • A field that is the same as the argument field (by identity comparison).
        • A field that is equal to the argument field (exact matching fully qualified name).
        • A field that is equal to the argument field (partially matching qualified name).
        • A field whose name is equal to the name of the argument field.
        • null otherwise.
        If several fields have the same name, the first one is returned and a warning is logged.
        See Also:
        Row.field(Field)

      • field

        Field<?> field​(java.lang.String name)
        Get a specific field from this Result.
        See Also:
        Row.field(String)

      • field

        <T> Field<T> field​(java.lang.String name,
                   java.lang.Class<T> type)
        Get a specific field from this Result, coerced to type.
        See Also:
        Row.field(String, Class)

      • field

        <T> Field<T> field​(Name name,
                   java.lang.Class<T> type)
        Get a specific field from this Result, coerced to type.
        See Also:
        Row.field(Name, Class)

      • field

        Field<?> field​(int index)
        Get a specific field from this Result.
        See Also:
        Row.field(int)

      • field

        <T> Field<T> field​(int index,
                   java.lang.Class<T> type)
        Get a specific field from this Result, coerced to type.
        See Also:
        Row.field(int, Class)

      • fields

        Field<?>[] fields()
        Get all fields from this Result.
        See Also:
        Row.fields()

      • fields

        Field<?>[] fields​(Field<?>... fields)
        Get all fields from this Result, providing some fields.
        Returns:
        All available fields
        See Also:
        Row.fields(Field...)

      • fields

        Field<?>[] fields​(java.lang.String... fieldNames)
        Get all fields from this Result, providing some field names.
        Returns:
        All available fields
        See Also:
        Row.fields(String...)

      • fields

        Field<?>[] fields​(Name... fieldNames)
        Get all fields from this Result, providing some field names.
        Returns:
        All available fields
        See Also:
        Row.fields(Name...)

      • fields

        Field<?>[] fields​(int... fieldIndexes)
        Get all fields from this Result, providing some field indexes.
        Returns:
        All available fields
        See Also:
        Row.fields(int...)

      • indexOf

        int indexOf​(Field<?> field)
        Get a field's index from this result.
        Parameters:
        field - The field to look for
        Returns:
        The field's index or -1 if the field is not contained in this result.

      • indexOf

        int indexOf​(java.lang.String fieldName)
        Get a field's index from this result.
        Parameters:
        fieldName - The field name to look for
        Returns:
        The field's index or -1 if the field is not contained in this result.

      • indexOf

        int indexOf​(Name fieldName)
        Get a field's index from this result.
        Parameters:
        fieldName - The field name to look for
        Returns:
        The field's index or -1 if the field is not contained in this result

      • getValue

        <T> T getValue​(int index,
               Field<T> field)
        throws java.lang.IndexOutOfBoundsException,
               java.lang.IllegalArgumentException
        Convenience method to fetch a value at a given position in the result.
        Type Parameters:
        T - The value's field's generic type parameter
        Parameters:
        index - The record's index
        field - The value's field
        Returns:
        The value
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • getValue

        @Deprecated
<T> T getValue​(int index,
               Field<T> field,
               T defaultValue)
        throws java.lang.IndexOutOfBoundsException,
               java.lang.IllegalArgumentException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Convenience method to fetch a value at a given position in the result.
        Type Parameters:
        T - The value's field's generic type parameter
        Parameters:
        index - The record's index
        field - The value's field
        defaultValue - The default value if the value was null
        Returns:
        The value
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • getValue

        java.lang.Object getValue​(int index,
                          int fieldIndex)
                   throws java.lang.IndexOutOfBoundsException,
                          java.lang.IllegalArgumentException
        Convenience method to fetch a value at a given position in the result.
        Parameters:
        index - The record's index
        fieldIndex - The value's field index
        Returns:
        The value
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

      • getValue

        @Deprecated
java.lang.Object getValue​(int index,
                          int fieldIndex,
                          java.lang.Object defaultValue)
                   throws java.lang.IndexOutOfBoundsException,
                          java.lang.IllegalArgumentException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Convenience method to fetch a value at a given position in the result.
        Parameters:
        index - The record's index
        fieldIndex - The value's field index
        defaultValue - The default value if the value was null
        Returns:
        The value
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()

      • getValue

        java.lang.Object getValue​(int index,
                          java.lang.String fieldName)
                   throws java.lang.IndexOutOfBoundsException,
                          java.lang.IllegalArgumentException
        Convenience method to fetch a value at a given position in the result.
        Parameters:
        index - The record's index
        fieldName - The value's field name
        Returns:
        The value
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

      • getValue

        @Deprecated
java.lang.Object getValue​(int index,
                          java.lang.String fieldName,
                          java.lang.Object defaultValue)
                   throws java.lang.IndexOutOfBoundsException,
                          java.lang.IllegalArgumentException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Convenience method to fetch a value at a given position in the result.
        Parameters:
        index - The record's index
        fieldName - The value's field name
        defaultValue - The default value if the value was null
        Returns:
        The value
        Throws:
        java.lang.IndexOutOfBoundsException - if the index is out of range ( index < 0 || index >= size())
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

      • getValues

        <T> java.util.List<T> getValues​(Field<T> field)
                         throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • getValues

        <T> java.util.List<T> getValues​(Field<?> field,
                                java.lang.Class<? extends T> type)
                         throws java.lang.IllegalArgumentException
        Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.
        Parameters:
        field - The values' field
        type - The type used for type conversion
        Returns:
        The values
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        See Also:
        Record.get(Field, Class), Convert.convert(Object, Class)

      • getValues

        <T,​U> java.util.List<U> getValues​(Field<T> field,
                                        Converter<? super T,​? extends U> converter)
                                 throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        See Also:
        Record.get(Field, Converter), Convert.convert(Object, Converter)

      • getValues

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

      • getValues

        <T> java.util.List<T> getValues​(int fieldIndex,
                                java.lang.Class<? extends T> type)
                         throws java.lang.IllegalArgumentException,
                                DataTypeException
        Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.
        Parameters:
        fieldIndex - The values' field index
        type - The type used for type conversion
        Returns:
        The values
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        Record.get(int, Class), Convert.convert(Object, Class)

      • getValues

        <U> java.util.List<U> getValues​(int fieldIndex,
                                Converter<?,​? extends U> converter)
                         throws java.lang.IllegalArgumentException,
                                DataTypeException
        Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.
        Parameters:
        fieldIndex - The values' field index
        converter - The data type converter used for type conversion
        Returns:
        The values
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        Record.get(int, Converter), Convert.convert(Object, Converter)

      • getValues

        java.util.List<?> getValues​(java.lang.String fieldName)
                     throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

      • getValues

        <T> java.util.List<T> getValues​(java.lang.String fieldName,
                                java.lang.Class<? extends T> type)
                         throws java.lang.IllegalArgumentException,
                                DataTypeException
        Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.
        Parameters:
        fieldName - The values' field name
        type - The type used for type conversion
        Returns:
        The values
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        Record.get(String, Class), Convert.convert(Object, Class)

      • getValues

        <U> java.util.List<U> getValues​(java.lang.String fieldName,
                                Converter<?,​? extends U> converter)
                         throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        Record.get(String, Converter), Convert.convert(Object, Converter)

      • getValues

        java.util.List<?> getValues​(Name fieldName)
                     throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()

      • getValues

        <T> java.util.List<T> getValues​(Name fieldName,
                                java.lang.Class<? extends T> type)
                         throws java.lang.IllegalArgumentException,
                                DataTypeException
        Convenience method to fetch all values for a given field. This is especially useful, when selecting only a single field.
        Parameters:
        fieldName - The values' field name
        type - The type used for type conversion
        Returns:
        The values
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        Record.get(Name, Class), Convert.convert(Object, Class)

      • getValues

        <U> java.util.List<U> getValues​(Name fieldName,
                                Converter<?,​? extends U> converter)
                         throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        Record.get(Name, Converter), Convert.convert(Object, Converter)

      • isEmpty

        boolean isEmpty()
        Whether there are any records contained in this Result.
        Specified by:
        isEmpty in interface java.util.Collection<R extends Record>
        Specified by:
        isEmpty in interface java.util.List<R extends Record>

      • isNotEmpty

        boolean isNotEmpty()
        Whether there are any records contained in this Result.

      • intoMaps

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

      • intoMap

        <K> java.util.Map<K,​R> intoMap​(Field<K> key)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException
        Return a Map with one of the result's columns as key and the corresponding records as value.

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

        Type Parameters:
        K - The key's generic field type
        Parameters:
        key - The key field. Client code must assure that this field is unique in the result set.
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        InvalidResultException - if the key field returned two or more equal values from the result set.

      • intoMap

        java.util.Map<?,​R> intoMap​(int keyFieldIndex)
                          throws java.lang.IllegalArgumentException,
                                 InvalidResultException
        Return a Map with one of the result's columns as key and the corresponding records as value.

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

        Parameters:
        keyFieldIndex - The key field index. Client code must assure that this field is unique in the result set.
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If the argument keyFieldIndex is not contained in fieldsRow()
        InvalidResultException - if the key field returned two or more equal values from the result set.

      • intoMap

        java.util.Map<?,​R> intoMap​(java.lang.String keyFieldName)
                          throws java.lang.IllegalArgumentException,
                                 InvalidResultException
        Return a Map with one of the result's columns as key and the corresponding records as value.

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

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

      • intoMap

        java.util.Map<?,​R> intoMap​(Name keyFieldName)
                          throws java.lang.IllegalArgumentException,
                                 InvalidResultException
        Return a Map with one of the result's columns as key and the corresponding records as value.

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

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

      • intoMap

        <K,​V> java.util.Map<K,​V> intoMap​(Field<K> key,
                                             Field<V> value)
                                      throws java.lang.IllegalArgumentException,
                                             InvalidResultException
        Return a Map with one of the result's columns as key and another one of the result's columns as value

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

        Type Parameters:
        K - The key's generic field type
        V - The value's generic field type
        Parameters:
        key - The key field. Client code must assure that this field is unique in the result set.
        value - The value field
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the key field returned two or more equal values from the result set.

      • intoMap

        java.util.Map<?,​?> intoMap​(int keyFieldIndex,
                                 int valueFieldIndex)
                          throws java.lang.IllegalArgumentException,
                                 InvalidResultException
        Return a Map with one of the result's columns as key and another one of the result's columns as value

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

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

      • intoMap

        java.util.Map<?,​?> intoMap​(java.lang.String keyFieldName,
                                 java.lang.String valueFieldName)
                          throws java.lang.IllegalArgumentException,
                                 InvalidResultException
        Return a Map with one of the result's columns as key and another one of the result's columns as value

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

        Parameters:
        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:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the key field returned two or more equal values from the result set.

      • intoMap

        java.util.Map<?,​?> intoMap​(Name keyFieldName,
                                 Name valueFieldName)
                          throws java.lang.IllegalArgumentException,
                                 InvalidResultException
        Return a Map with one of the result's columns as key and another one of the result's columns as value

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

        Parameters:
        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:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the key field returned two or more equal values from the result set.

      • intoMap

        <K,​E> java.util.Map<K,​E> intoMap​(Field<K> key,
                                             java.lang.Class<? extends E> type)
                                      throws java.lang.IllegalArgumentException,
                                             InvalidResultException,
                                             MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(Field, Class) instead, if your key is non-unique.

        Parameters:
        key - The key. Client code must assure that key is unique in the result set.
        type - The entity type.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<?,​E> intoMap​(int keyFieldIndex,
                                     java.lang.Class<? extends E> type)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(int, Class) instead, if your key is non-unique.

        Parameters:
        keyFieldIndex - The key. Client code must assure that key is unique in the result set.
        type - The entity type.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field index is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<?,​E> intoMap​(java.lang.String keyFieldName,
                                     java.lang.Class<? extends E> type)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(String, Class) instead, if your key is non-unique.

        Parameters:
        keyFieldName - The key. Client code must assure that key is unique in the result set.
        type - The entity type.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field name is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<?,​E> intoMap​(Name keyFieldName,
                                     java.lang.Class<? extends E> type)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(Name, Class) instead, if your key is non-unique.

        Parameters:
        keyFieldName - The key. Client code must assure that key is unique in the result set.
        type - The entity type.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field name is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <K,​E> java.util.Map<K,​E> intoMap​(Field<K> key,
                                             RecordMapper<? super R,​E> mapper)
                                      throws java.lang.IllegalArgumentException,
                                             InvalidResultException,
                                             MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(Field, Class) instead, if your key is non-unique.

        Parameters:
        key - The key. Client code must assure that key is unique in the result set.
        mapper - The mapper callback.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<?,​E> intoMap​(int keyFieldIndex,
                                     RecordMapper<? super R,​E> mapper)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(int, Class) instead, if your key is non-unique.

        Parameters:
        keyFieldIndex - The key. Client code must assure that key is unique in the result set.
        mapper - The mapper callback.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field index is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<?,​E> intoMap​(java.lang.String keyFieldName,
                                     RecordMapper<? super R,​E> mapper)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(String, Class) instead, if your key is non-unique.

        Parameters:
        keyFieldName - The key. Client code must assure that key is unique in the result set.
        mapper - The mapper callback.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field name is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<?,​E> intoMap​(Name keyFieldName,
                                     RecordMapper<? super R,​E> mapper)
                              throws java.lang.IllegalArgumentException,
                                     InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.

        An InvalidResultException is thrown, if the key is non-unique in the result set. Use intoGroups(Name, Class) instead, if your key is non-unique.

        Parameters:
        keyFieldName - The key. Client code must assure that key is unique in the result set.
        mapper - The mapper callback.
        Returns:
        A Map containing the result.
        Throws:
        java.lang.IllegalArgumentException - If the argument field name is not contained in fieldsRow()
        InvalidResultException - if the key is non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        java.util.Map<Record,​R> intoMap​(Field<?>[] keys)
                               throws java.lang.IllegalArgumentException,
                                      InvalidResultException
        Return a Map with the given keys as a map key and the corresponding record as value.

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

        Parameters:
        keys - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​R> intoMap​(int[] keyFieldIndexes)
                               throws java.lang.IllegalArgumentException,
                                      InvalidResultException
        Return a Map with the given keys as a map key and the corresponding record as value.

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

        Parameters:
        keyFieldIndexes - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field indexes is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​R> intoMap​(java.lang.String[] keyFieldNames)
                               throws java.lang.IllegalArgumentException,
                                      InvalidResultException
        Return a Map with the given keys as a map key and the corresponding record as value.

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

        Parameters:
        keyFieldNames - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​R> intoMap​(Name[] keyFieldNames)
                               throws java.lang.IllegalArgumentException,
                                      InvalidResultException
        Return a Map with the given keys as a map key and the corresponding record as value.

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

        Parameters:
        keyFieldNames - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​Record> intoMap​(Field<?>[] keys,
                                           Field<?>[] values)
                                    throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​Record> intoMap​(int[] keyFieldIndexes,
                                           int[] valueFieldIndexes)
                                    throws java.lang.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.

        Parameters:
        keyFieldIndexes - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        valueFieldIndexes - The values.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field indexes is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​Record> intoMap​(java.lang.String[] keyFieldNames,
                                           java.lang.String[] valueFieldNames)
                                    throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        java.util.Map<Record,​Record> intoMap​(Name[] keyFieldNames,
                                           Name[] valueFieldNames)
                                    throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(Field<?>[] keys,
                                                     java.lang.Class<? extends E> type)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keys - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(int[] keyFieldIndexes,
                                                     java.lang.Class<? extends E> type)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldIndexes - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field indexes is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(java.lang.String[] keyFieldNames,
                                                     java.lang.Class<? extends E> type)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldNames - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(Name[] keyFieldNames,
                                                     java.lang.Class<? extends E> type)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldNames - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(Field<?>[] keys,
                                                     RecordMapper<? super R,​E> mapper)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped by the given mapper.

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

        Parameters:
        keys - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(int[] keyFieldIndexes,
                                                     RecordMapper<? super R,​E> mapper)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped by the given mapper.

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

        Parameters:
        keyFieldIndexes - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field indexes is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(java.lang.String[] keyFieldNames,
                                                     RecordMapper<? super R,​E> mapper)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped by the given mapper.

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

        Parameters:
        keyFieldNames - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E> java.util.Map<java.util.List<?>,​E> intoMap​(Name[] keyFieldNames,
                                                     RecordMapper<? super R,​E> mapper)
                                              throws java.lang.IllegalArgumentException,
                                                     InvalidResultException,
                                                     MappingException
        Return a Map with results grouped by the given keys and mapped by the given mapper.

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

        Parameters:
        keyFieldNames - The keys. Client code must assure that keys are unique in the result set. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <K> java.util.Map<K,​R> intoMap​(java.lang.Class<? extends K> keyType)
                              throws MappingException,
                                     InvalidResultException
        Return a Map with results grouped by the given key entity.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyType - The key type. If this is null, the resulting map will contain at most one entry.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        InvalidResultException - if the keys are non-unique in the result set.
        See Also:
        DefaultRecordMapper

      • intoMap

        <K,​V> java.util.Map<K,​V> intoMap​(java.lang.Class<? extends K> keyType,
                                             java.lang.Class<? extends V> valueType)
                                      throws MappingException,
                                             InvalidResultException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyType - The key type. If this is null, the resulting map will contain at most one entry.
        valueType - The value type.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        InvalidResultException - if the keys are non-unique in the result set.
        See Also:
        DefaultRecordMapper

      • intoMap

        <K,​V> java.util.Map<K,​V> intoMap​(java.lang.Class<? extends K> keyType,
                                             RecordMapper<? super R,​V> valueMapper)
                                      throws InvalidResultException,
                                             MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyType - The key type. If this is null, the resulting map will contain at most one entry.
        valueMapper - The value mapper.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        InvalidResultException - if the keys are non-unique in the result set.
        See Also:
        DefaultRecordMapper

      • intoMap

        <K> java.util.Map<K,​R> intoMap​(RecordMapper<? super R,​K> keyMapper)
                              throws InvalidResultException,
                                     MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyMapper - The key mapper.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        InvalidResultException - if the keys are non-unique in the result set.
        See Also:
        DefaultRecordMapper

      • intoMap

        <K,​V> java.util.Map<K,​V> intoMap​(RecordMapper<? super R,​K> keyMapper,
                                             java.lang.Class<V> valueType)
                                      throws InvalidResultException,
                                             MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyMapper - The key mapper.
        valueType - The value type.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        InvalidResultException - if the keys are non-unique in the result set.
        See Also:
        DefaultRecordMapper

      • intoMap

        <K,​V> java.util.Map<K,​V> intoMap​(RecordMapper<? super R,​K> keyMapper,
                                             RecordMapper<? super R,​V> valueMapper)
                                      throws InvalidResultException,
                                             MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyMapper - The key mapper.
        valueMapper - The value mapper.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        InvalidResultException - if the keys are non-unique in the result set.
        See Also:
        DefaultRecordMapper

      • intoMap

        <S extends Record> java.util.Map<S,​R> intoMap​(Table<S> table)
                                             throws java.lang.IllegalArgumentException,
                                                    InvalidResultException
        Return a Map with the given key table as a map key and the corresponding record as value.

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

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

      • intoMap

        <S extends Record,​T extends Record> java.util.Map<S,​T> intoMap​(Table<S> keyTable,
                                                                           Table<T> valueTable)
                                                                    throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.

      • intoMap

        <E,​S extends Record> java.util.Map<S,​E> intoMap​(Table<S> table,
                                                            java.lang.Class<? extends E> type)
                                                     throws java.lang.IllegalArgumentException,
                                                            InvalidResultException,
                                                            MappingException
        Return a Map with results grouped by the given key table and mapped into the given entity type.

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

        Parameters:
        table - The key table. Client code must assure that keys are unique in the result set. May not be null.
        type - The entity type.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoMap

        <E,​S extends Record> java.util.Map<S,​E> intoMap​(Table<S> table,
                                                            RecordMapper<? super R,​E> mapper)
                                                     throws java.lang.IllegalArgumentException,
                                                            InvalidResultException,
                                                            MappingException
        Return a Map with results grouped by the given key table and mapped by the given mapper.

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

        Parameters:
        table - The key table. Client code must assure that keys are unique in the result set. May not be null.
        mapper - The mapper callback.
        Returns:
        A Map containing the results.
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()
        InvalidResultException - if the keys are non-unique in the result set.
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K> java.util.Map<K,​Result<R>> intoGroups​(Field<K> key)
                                         throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and a list of corresponding records as value.

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

        Type Parameters:
        K - The key's generic field type
        Parameters:
        key - The key field.
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • intoGroups

        java.util.Map<?,​Result<R>> intoGroups​(int keyFieldIndex)
                                     throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and a list of corresponding records as value.

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

        Parameters:
        keyFieldIndex - The key field index.
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If the argument field index is not contained in fieldsRow()

      • intoGroups

        java.util.Map<?,​Result<R>> intoGroups​(java.lang.String keyFieldName)
                                     throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and a list of corresponding records as value.

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

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

      • intoGroups

        java.util.Map<?,​Result<R>> intoGroups​(Name keyFieldName)
                                     throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and a list of corresponding records as value.

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

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

      • intoGroups

        <K,​V> java.util.Map<K,​java.util.List<V>> intoGroups​(Field<K> key,
                                                                Field<V> value)
                                                         throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and another one of the result's columns as value.

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

        Type Parameters:
        K - The key's generic field type
        V - The value's generic field type
        Parameters:
        key - The key field.
        value - The value field
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

      • intoGroups

        java.util.Map<?,​java.util.List<?>> intoGroups​(int keyFieldIndex,
                                                    int valueFieldIndex)
                                             throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and another one of the result's columns as value.

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

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

      • intoGroups

        java.util.Map<?,​java.util.List<?>> intoGroups​(java.lang.String keyFieldName,
                                                    java.lang.String valueFieldName)
                                             throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and another one of the result's columns as value.

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

        Parameters:
        keyFieldName - The key field name.
        valueFieldName - The value field name.
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()

      • intoGroups

        java.util.Map<?,​java.util.List<?>> intoGroups​(Name keyFieldName,
                                                    Name valueFieldName)
                                             throws java.lang.IllegalArgumentException
        Return a Map with one of the result's columns as key and another one of the result's columns as value.

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

        Parameters:
        keyFieldName - The key field name.
        valueFieldName - The value field name.
        Returns:
        A Map containing the results
        Throws:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()

      • intoGroups

        <K,​E> java.util.Map<K,​java.util.List<E>> intoGroups​(Field<K> key,
                                                                java.lang.Class<? extends E> type)
                                                         throws java.lang.IllegalArgumentException,
                                                                MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

        Type Parameters:
        K - The key's generic field type
        E - The generic entity type.
        Parameters:
        key - The key field.
        type - The entity type.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<?,​java.util.List<E>> intoGroups​(int keyFieldIndex,
                                                        java.lang.Class<? extends E> type)
                                                 throws java.lang.IllegalArgumentException,
                                                        MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

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

      • intoGroups

        <E> java.util.Map<?,​java.util.List<E>> intoGroups​(java.lang.String keyFieldName,
                                                        java.lang.Class<? extends E> type)
                                                 throws java.lang.IllegalArgumentException,
                                                        MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

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

      • intoGroups

        <E> java.util.Map<?,​java.util.List<E>> intoGroups​(Name keyFieldName,
                                                        java.lang.Class<? extends E> type)
                                                 throws java.lang.IllegalArgumentException,
                                                        MappingException
        Return a Map with results grouped by the given key and mapped into the given entity type.

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

      • intoGroups

        <K,​E> java.util.Map<K,​java.util.List<E>> intoGroups​(Field<K> key,
                                                                RecordMapper<? super R,​E> mapper)
                                                         throws java.lang.IllegalArgumentException,
                                                                MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.
        Type Parameters:
        K - The key's generic field type
        E - The generic entity type.
        Parameters:
        key - The key field.
        mapper - The mapper callback.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

      • intoGroups

        <E> java.util.Map<?,​java.util.List<E>> intoGroups​(int keyFieldIndex,
                                                        RecordMapper<? super R,​E> mapper)
                                                 throws java.lang.IllegalArgumentException,
                                                        MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.
        Parameters:
        keyFieldIndex - The key field index.
        mapper - The mapper callback.
        Throws:
        java.lang.IllegalArgumentException - If the argument field index is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

      • intoGroups

        <E> java.util.Map<?,​java.util.List<E>> intoGroups​(java.lang.String keyFieldName,
                                                        RecordMapper<? super R,​E> mapper)
                                                 throws java.lang.IllegalArgumentException,
                                                        MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.
        Parameters:
        keyFieldName - The key field name.
        mapper - The mapper callback.
        Throws:
        java.lang.IllegalArgumentException - If the argument field name is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

      • intoGroups

        <E> java.util.Map<?,​java.util.List<E>> intoGroups​(Name keyFieldName,
                                                        RecordMapper<? super R,​E> mapper)
                                                 throws java.lang.IllegalArgumentException,
                                                        MappingException
        Return a Map with results grouped by the given key and mapped by the given mapper.
        Parameters:
        keyFieldName - The key field name.
        mapper - The mapper callback.
        Throws:
        java.lang.IllegalArgumentException - If the argument field name is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records

      • intoGroups

        java.util.Map<Record,​Result<R>> intoGroups​(Field<?>[] keys)
                                          throws java.lang.IllegalArgumentException
        Return a Map with the result grouped by the given keys.

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

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

      • intoGroups

        java.util.Map<Record,​Result<R>> intoGroups​(int[] keyFieldIndexes)
                                          throws java.lang.IllegalArgumentException
        Return a Map with the result grouped by the given keys.

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

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

      • intoGroups

        java.util.Map<Record,​Result<R>> intoGroups​(java.lang.String[] keyFieldNames)
                                          throws java.lang.IllegalArgumentException
        Return a Map with the result grouped by the given keys.

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

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

      • intoGroups

        java.util.Map<Record,​Result<R>> intoGroups​(Name[] keyFieldNames)
                                          throws java.lang.IllegalArgumentException
        Return a Map with the result grouped by the given keys.

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

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

      • intoGroups

        java.util.Map<Record,​Result<Record>> intoGroups​(Field<?>[] keys,
                                                      Field<?>[] values)
                                               throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

      • intoGroups

        java.util.Map<Record,​Result<Record>> intoGroups​(int[] keyFieldIndexes,
                                                      int[] valueFieldIndexes)
                                               throws java.lang.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.

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

      • intoGroups

        java.util.Map<Record,​Result<Record>> intoGroups​(java.lang.String[] keyFieldNames,
                                                      java.lang.String[] valueFieldNames)
                                               throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()

      • intoGroups

        java.util.Map<Record,​Result<Record>> intoGroups​(Name[] keyFieldNames,
                                                      Name[] valueFieldNames)
                                               throws java.lang.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.

        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:
        java.lang.IllegalArgumentException - If any of the argument field names is not contained in fieldsRow()

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(Field<?>[] keys,
                                                             java.lang.Class<? extends E> type)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keys - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument fields is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(int[] keyFieldIndexes,
                                                             java.lang.Class<? extends E> type)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldIndexes - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument field indexes is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(java.lang.String[] keyFieldNames,
                                                             java.lang.Class<? extends E> type)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldNames - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument field names is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(Name[] keyFieldNames,
                                                             java.lang.Class<? extends E> type)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldNames - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        type - The entity type.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument field names is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(Field<?>[] keys,
                                                             RecordMapper<? super R,​E> mapper)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keys - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument fields is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(int[] keyFieldIndexes,
                                                             RecordMapper<? super R,​E> mapper)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldIndexes - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument field indexes is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(java.lang.String[] keyFieldNames,
                                                             RecordMapper<? super R,​E> mapper)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldNames - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument field indexes is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E> java.util.Map<Record,​java.util.List<E>> intoGroups​(Name[] keyFieldNames,
                                                             RecordMapper<? super R,​E> mapper)
                                                      throws java.lang.IllegalArgumentException,
                                                             MappingException
        Return a Map with results grouped by the given keys and mapped into the given entity type.

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

        Parameters:
        keyFieldNames - The keys. If this is null or an empty array, the resulting map will contain at most one entry.
        mapper - The mapper callback.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument field indexes is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K> java.util.Map<K,​Result<R>> intoGroups​(java.lang.Class<? extends K> keyType)
                                         throws MappingException
        Return a Map with results grouped by the given key entity.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyType - The key type. If this is null, the resulting map will contain at most one entry.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K,​V> java.util.Map<K,​java.util.List<V>> intoGroups​(java.lang.Class<? extends K> keyType,
                                                                java.lang.Class<? extends V> valueType)
                                                         throws MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyType - The key type. If this is null, the resulting map will contain at most one entry.
        valueType - The value type.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K,​V> java.util.Map<K,​java.util.List<V>> intoGroups​(java.lang.Class<? extends K> keyType,
                                                                RecordMapper<? super R,​V> valueMapper)
                                                         throws MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyType - The key type. If this is null, the resulting map will contain at most one entry.
        valueMapper - The value mapper.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K> java.util.Map<K,​Result<R>> intoGroups​(RecordMapper<? super R,​K> keyMapper)
                                         throws MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyMapper - The key mapper.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K,​V> java.util.Map<K,​java.util.List<V>> intoGroups​(RecordMapper<? super R,​K> keyMapper,
                                                                java.lang.Class<V> valueType)
                                                         throws MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyMapper - The key mapper.
        valueType - The value type.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <K,​V> java.util.Map<K,​java.util.List<V>> intoGroups​(RecordMapper<? super R,​K> keyMapper,
                                                                RecordMapper<? super R,​V> valueMapper)
                                                         throws MappingException
        Return a Map with results grouped by the given key entity and mapped into the given entity type.

        The grouping semantics is governed by the key type's Object.equals(Object) and Object.hashCode() implementation, not necessarily the values as fetched from the database.

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

        Parameters:
        keyMapper - The key mapper.
        valueMapper - The value mapper.
        Returns:
        A Map containing grouped results
        Throws:
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <S extends Record> java.util.Map<S,​Result<R>> intoGroups​(Table<S> table)
                                                        throws java.lang.IllegalArgumentException
        Return a Map with the result grouped by the given key table.

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

        Parameters:
        table - The key table. May not be null.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If any of the argument fields is not contained in fieldsRow()

      • intoGroups

        <S extends Record,​T extends Record> java.util.Map<S,​Result<T>> intoGroups​(Table<S> keyTable,
                                                                                      Table<T> valueTable)
                                                                               throws java.lang.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.

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

      • intoGroups

        <E,​S extends Record> java.util.Map<S,​java.util.List<E>> intoGroups​(Table<S> table,
                                                                               java.lang.Class<? extends E> type)
                                                                        throws java.lang.IllegalArgumentException,
                                                                               MappingException
        Return a Map with results grouped by the given key table and mapped into the given entity type.

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

        Parameters:
        table - The key table. May not be null.
        type - The entity type.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument fields is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoGroups

        <E,​S extends Record> java.util.Map<S,​java.util.List<E>> intoGroups​(Table<S> table,
                                                                               RecordMapper<? super R,​E> mapper)
                                                                        throws java.lang.IllegalArgumentException,
                                                                               MappingException
        Return a Map with results grouped by the given key table and mapped into the given entity type.

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

        Parameters:
        table - The key table. May not be null.
        mapper - The mapper callback.
        Returns:
        A Map containing grouped results
        Throws:
        java.lang.IllegalArgumentException - If the any of the argument fields is not contained in fieldsRow()
        MappingException - wrapping any reflection or data type conversion exception that might have occurred while mapping records
        See Also:
        DefaultRecordMapper

      • intoArray

        @Deprecated
java.lang.Object[][] intoArray()
        Deprecated.
        - 3.6.0 - [#3879] - Use intoArrays() instead.

      • intoArrays

        java.lang.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

        java.lang.Object[] intoArray​(int fieldIndex)
                      throws java.lang.IllegalArgumentException
        Return all values for a field index from the result.

        You can access data like this 

        result.intoArray(fieldIndex)[recordIndex]
        Returns:
        The resulting values. This may be an array type more concrete than Object[], depending on whether jOOQ has any knowledge about fieldIndex's actual type.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()
        See Also:
        getValues(int)

      • intoArray

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

        You can access data like this 

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

      • intoArray

        <U> U[] intoArray​(int fieldIndex,
                  Converter<?,​? extends U> converter)
           throws java.lang.IllegalArgumentException,
                  DataTypeException
        Return all values for a field index from the result.

        You can access data like this 

        result.intoArray(fieldIndex)[recordIndex]
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(int, Converter)

      • intoArray

        java.lang.Object[] intoArray​(java.lang.String fieldName)
                      throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        See Also:
        getValues(String)

      • intoArray

        <T> T[] intoArray​(java.lang.String fieldName,
                  java.lang.Class<? extends T> type)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(String, Class)

      • intoArray

        <U> U[] intoArray​(java.lang.String fieldName,
                  Converter<?,​? extends U> converter)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(String, Converter)

      • intoArray

        java.lang.Object[] intoArray​(Name fieldName)
                      throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        See Also:
        getValues(Name)

      • intoArray

        <T> T[] intoArray​(Name fieldName,
                  java.lang.Class<? extends T> type)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Name, Class)

      • intoArray

        <U> U[] intoArray​(Name fieldName,
                  Converter<?,​? extends U> converter)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Name, Converter)

      • intoArray

        <T> T[] intoArray​(Field<T> field)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        See Also:
        getValues(Field)

      • intoArray

        <T> T[] intoArray​(Field<?> field,
                  java.lang.Class<? extends T> type)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Field, Class)

      • intoArray

        <T,​U> U[] intoArray​(Field<T> field,
                          Converter<? super T,​? extends U> converter)
                   throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Field, Converter)

      • intoSet

        <E> java.util.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

        java.util.Set<?> intoSet​(int fieldIndex)
                  throws java.lang.IllegalArgumentException
        Return all values for a field index from the result.
        Returns:
        The resulting values. This may be an array type more concrete than Object[], depending on whether jOOQ has any knowledge about fieldIndex's actual type.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldIndex is not contained in fieldsRow()
        See Also:
        getValues(int)

      • intoSet

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

      • intoSet

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

      • intoSet

        java.util.Set<?> intoSet​(java.lang.String fieldName)
                  throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        See Also:
        getValues(String)

      • intoSet

        <T> java.util.Set<T> intoSet​(java.lang.String fieldName,
                             java.lang.Class<? extends T> type)
                      throws java.lang.IllegalArgumentException,
                             DataTypeException
        Return all values for a field name from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(String, Class)

      • intoSet

        <U> java.util.Set<U> intoSet​(java.lang.String fieldName,
                             Converter<?,​? extends U> converter)
                      throws java.lang.IllegalArgumentException,
                             DataTypeException
        Return all values for a field name from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(String, Converter)

      • intoSet

        java.util.Set<?> intoSet​(Name fieldName)
                  throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        See Also:
        getValues(Name)

      • intoSet

        <T> java.util.Set<T> intoSet​(Name fieldName,
                             java.lang.Class<? extends T> type)
                      throws java.lang.IllegalArgumentException,
                             DataTypeException
        Return all values for a field name from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Name, Class)

      • intoSet

        <U> java.util.Set<U> intoSet​(Name fieldName,
                             Converter<?,​? extends U> converter)
                      throws java.lang.IllegalArgumentException,
                             DataTypeException
        Return all values for a field name from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument fieldName is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Name, Converter)

      • intoSet

        <T> java.util.Set<T> intoSet​(Field<T> field)
                      throws java.lang.IllegalArgumentException
        Return all values for a field from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        See Also:
        getValues(Field)

      • intoSet

        <T> java.util.Set<T> intoSet​(Field<?> field,
                             java.lang.Class<? extends T> type)
                      throws java.lang.IllegalArgumentException,
                             DataTypeException
        Return all values for a field from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Field, Class)

      • intoSet

        <T,​U> java.util.Set<U> intoSet​(Field<T> field,
                                     Converter<? super T,​? extends U> converter)
                              throws java.lang.IllegalArgumentException,
                                     DataTypeException
        Return all values for a field from the result.
        Returns:
        The resulting values.
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
        See Also:
        getValues(Field, Converter)

      • into

        Result<Record> into​(Field<?>... fields)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Parameters:
        fields - The fields of the new records
        Returns:
        The new result

      • into

        <T1> Result<Record1<T1>> into​(Field<T1> field1)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2> Result<Record2<T1,​T2>> into​(Field<T1> field1,
                                                Field<T2> field2)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3> Result<Record3<T1,​T2,​T3>> into​(Field<T1> field1,
                                                                  Field<T2> field2,
                                                                  Field<T3> field3)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4> Result<Record4<T1,​T2,​T3,​T4>> into​(Field<T1> field1,
                                                                                    Field<T2> field2,
                                                                                    Field<T3> field3,
                                                                                    Field<T4> field4)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5> Result<Record5<T1,​T2,​T3,​T4,​T5>> into​(Field<T1> field1,
                                                                                                      Field<T2> field2,
                                                                                                      Field<T3> field3,
                                                                                                      Field<T4> field4,
                                                                                                      Field<T5> field5)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6> Result<Record6<T1,​T2,​T3,​T4,​T5,​T6>> into​(Field<T1> field1,
                                                                                                                        Field<T2> field2,
                                                                                                                        Field<T3> field3,
                                                                                                                        Field<T4> field4,
                                                                                                                        Field<T5> field5,
                                                                                                                        Field<T6> field6)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7> Result<Record7<T1,​T2,​T3,​T4,​T5,​T6,​T7>> into​(Field<T1> field1,
                                                                                                                                          Field<T2> field2,
                                                                                                                                          Field<T3> field3,
                                                                                                                                          Field<T4> field4,
                                                                                                                                          Field<T5> field5,
                                                                                                                                          Field<T6> field6,
                                                                                                                                          Field<T7> field7)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> Result<Record8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>> into​(Field<T1> field1,
                                                                                                                                                            Field<T2> field2,
                                                                                                                                                            Field<T3> field3,
                                                                                                                                                            Field<T4> field4,
                                                                                                                                                            Field<T5> field5,
                                                                                                                                                            Field<T6> field6,
                                                                                                                                                            Field<T7> field7,
                                                                                                                                                            Field<T8> field8)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> Result<Record9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>> into​(Field<T1> field1,
                                                                                                                                                                              Field<T2> field2,
                                                                                                                                                                              Field<T3> field3,
                                                                                                                                                                              Field<T4> field4,
                                                                                                                                                                              Field<T5> field5,
                                                                                                                                                                              Field<T6> field6,
                                                                                                                                                                              Field<T7> field7,
                                                                                                                                                                              Field<T8> field8,
                                                                                                                                                                              Field<T9> field9)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> Result<Record10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>> into​(Field<T1> field1,
                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                   Field<T10> field10)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> Result<Record11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>> into​(Field<T1> field1,
                                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                                       Field<T8> field8,
                                                                                                                                                                                                                       Field<T9> field9,
                                                                                                                                                                                                                       Field<T10> field10,
                                                                                                                                                                                                                       Field<T11> field11)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> Result<Record12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>> into​(Field<T1> field1,
                                                                                                                                                                                                                                           Field<T2> field2,
                                                                                                                                                                                                                                           Field<T3> field3,
                                                                                                                                                                                                                                           Field<T4> field4,
                                                                                                                                                                                                                                           Field<T5> field5,
                                                                                                                                                                                                                                           Field<T6> field6,
                                                                                                                                                                                                                                           Field<T7> field7,
                                                                                                                                                                                                                                           Field<T8> field8,
                                                                                                                                                                                                                                           Field<T9> field9,
                                                                                                                                                                                                                                           Field<T10> field10,
                                                                                                                                                                                                                                           Field<T11> field11,
                                                                                                                                                                                                                                           Field<T12> field12)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> Result<Record13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                               Field<T2> field2,
                                                                                                                                                                                                                                                               Field<T3> field3,
                                                                                                                                                                                                                                                               Field<T4> field4,
                                                                                                                                                                                                                                                               Field<T5> field5,
                                                                                                                                                                                                                                                               Field<T6> field6,
                                                                                                                                                                                                                                                               Field<T7> field7,
                                                                                                                                                                                                                                                               Field<T8> field8,
                                                                                                                                                                                                                                                               Field<T9> field9,
                                                                                                                                                                                                                                                               Field<T10> field10,
                                                                                                                                                                                                                                                               Field<T11> field11,
                                                                                                                                                                                                                                                               Field<T12> field12,
                                                                                                                                                                                                                                                               Field<T13> field13)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> Result<Record14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                                                   Field<T10> field10,
                                                                                                                                                                                                                                                                                   Field<T11> field11,
                                                                                                                                                                                                                                                                                   Field<T12> field12,
                                                                                                                                                                                                                                                                                   Field<T13> field13,
                                                                                                                                                                                                                                                                                   Field<T14> field14)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> Result<Record15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                                                                                                                       Field<T8> field8,
                                                                                                                                                                                                                                                                                                       Field<T9> field9,
                                                                                                                                                                                                                                                                                                       Field<T10> field10,
                                                                                                                                                                                                                                                                                                       Field<T11> field11,
                                                                                                                                                                                                                                                                                                       Field<T12> field12,
                                                                                                                                                                                                                                                                                                       Field<T13> field13,
                                                                                                                                                                                                                                                                                                       Field<T14> field14,
                                                                                                                                                                                                                                                                                                       Field<T15> field15)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> Result<Record16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                           Field<T2> field2,
                                                                                                                                                                                                                                                                                                                           Field<T3> field3,
                                                                                                                                                                                                                                                                                                                           Field<T4> field4,
                                                                                                                                                                                                                                                                                                                           Field<T5> field5,
                                                                                                                                                                                                                                                                                                                           Field<T6> field6,
                                                                                                                                                                                                                                                                                                                           Field<T7> field7,
                                                                                                                                                                                                                                                                                                                           Field<T8> field8,
                                                                                                                                                                                                                                                                                                                           Field<T9> field9,
                                                                                                                                                                                                                                                                                                                           Field<T10> field10,
                                                                                                                                                                                                                                                                                                                           Field<T11> field11,
                                                                                                                                                                                                                                                                                                                           Field<T12> field12,
                                                                                                                                                                                                                                                                                                                           Field<T13> field13,
                                                                                                                                                                                                                                                                                                                           Field<T14> field14,
                                                                                                                                                                                                                                                                                                                           Field<T15> field15,
                                                                                                                                                                                                                                                                                                                           Field<T16> field16)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17> Result<Record17<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                               Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                               Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                               Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                               Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                               Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                               Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                               Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                               Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                               Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                               Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                               Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                               Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                               Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                               Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                               Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                               Field<T17> field17)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18> Result<Record18<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                   Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                   Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                   Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                   Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                   Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                   Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                   Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                   Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                   Field<T18> field18)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19> Result<Record19<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                       Field<T19> field19)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20> Result<Record20<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                           Field<T20> field20)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21> Result<Record21<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                               Field<T21> field21)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22> Result<Record22<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22>> into​(Field<T1> field1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T2> field2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T3> field3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T4> field4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T5> field5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T6> field6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T7> field7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T8> field8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T9> field9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T10> field10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T11> field11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T12> field12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T13> field13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T14> field14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T15> field15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T16> field16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T17> field17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T18> field18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T19> field19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T20> field20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T21> field21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                   Field<T22> field22)
        Copy all records from this result into a new result with new records holding only a subset of the previous fields.
        Returns:
        The new result

      • into

        <E> java.util.List<E> into​(java.lang.Class<? extends E> type)
                    throws MappingException
        Map resulting records onto a custom type.

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

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

      • into

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

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

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

      • into

        <H extends RecordHandler<? super R>> H into​(H handler)
        Map results into a custom handler callback.
        Parameters:
        handler - The handler callback
        Returns:
        Convenience result, returning the parameter handler itself

      • intoResultSet

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

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

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

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

        Returns:
        A wrapper JDBC ResultSet

      • map

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

      • sortAsc

        <T extends java.lang.Comparable<? super T>> Result<R> sortAsc​(Field<T> field)
                                                       throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

        <T extends java.lang.Comparable<? super T>> Result<R> sortDesc​(Field<T> field)
                                                        throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

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

        nulls are sorted last by this method.

        Parameters:
        fieldIndex - The sort field index
        Returns:
        The result itself
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

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

        nulls are sorted last by this method.

        Parameters:
        fieldIndex - The sort field index
        Returns:
        The result itself
        Throws:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

        Result<R> sortAsc​(java.lang.String fieldName)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

        Result<R> sortDesc​(java.lang.String fieldName)
            throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

        Result<R> sortAsc​(Name fieldName)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

        Result<R> sortDesc​(Name fieldName)
            throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

        <T> Result<R> sortAsc​(Field<T> field,
                      java.util.Comparator<? super T> comparator)
               throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

        <T> Result<R> sortDesc​(Field<T> field,
                       java.util.Comparator<? super T> comparator)
                throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

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

        null sorting must be handled by the supplied comparator.

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

      • sortDesc

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

        null sorting must be handled by the supplied comparator.

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

      • sortAsc

        Result<R> sortAsc​(java.lang.String fieldName,
                  java.util.Comparator<?> comparator)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

        Result<R> sortDesc​(java.lang.String fieldName,
                   java.util.Comparator<?> comparator)
            throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

        Result<R> sortAsc​(Name fieldName,
                  java.util.Comparator<?> comparator)
           throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortDesc

        Result<R> sortDesc​(Name fieldName,
                   java.util.Comparator<?> comparator)
            throws java.lang.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:
        java.lang.IllegalArgumentException - If the argument field is not contained in fieldsRow()

      • sortAsc

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

      • sortDesc

        Result<R> sortDesc​(java.util.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

        @Deprecated
Result<R> intern​(Field<?>... fields)
        Deprecated.
        - 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

        @Deprecated
Result<R> intern​(int... fieldIndexes)
        Deprecated.
        - 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 field indexes whose values should be interned
        Returns:
        The same result
        See Also:
        intern(Field...), String.intern()

      • intern

        @Deprecated
Result<R> intern​(java.lang.String... fieldNames)
        Deprecated.
        - 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

        @Deprecated
Result<R> intern​(Name... fieldNames)
        Deprecated.
        - 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()

      • 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