-
- Type Parameters:
R
- The record type contained in this result
- All Superinterfaces:
Attachable
,java.util.Collection<R>
,Formattable
,java.lang.Iterable<R>
,java.util.List<R>
,java.io.Serializable
public interface Result<R extends Record> extends java.util.List<R>, Attachable, Formattable
A wrapper for database results returned bySelectQuery
- Author:
- Lukas Eder
- See Also:
ResultQuery.getResult()
-
-
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 newConfiguration
.void
detach()
Detach this result and all of its contained records from their currentConfiguration
.<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 totype
.<T> Field<T>
field(int index, DataType<T> dataType)
Get a specific field from this Result, coerced todataType
.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 totype
.<T> Field<T>
field(java.lang.String name, DataType<T> dataType)
Get a specific field from this Result, coerced todataType
.<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 totype
.<T> Field<T>
field(Name name, DataType<T> dataType)
Get a specific field from this Result, coerced todataType
.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 aRow
.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.0java.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.0java.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.0Result<R>
intern(java.lang.String... fieldNames)
Deprecated.- 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0Result<R>
intern(Field<?>... fields)
Deprecated.- 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0Result<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>>
Hinto(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] - UseintoArrays()
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 aMap
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 aMap
with the result grouped by the given keys.java.util.Map<Record,Result<Record>>
intoGroups(int[] keyFieldIndexes, int[] valueFieldIndexes)
Return aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given key and mapped by the given mapper.java.util.Map<Record,Result<R>>
intoGroups(Field<?>[] keys)
Return aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given key and mapped by the given mapper.java.util.Map<?,Result<R>>
intoGroups(Name keyFieldName)
Return aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
with the result grouped by the given key table.java.util.Map<?,R>
intoMap(int keyFieldIndex)
Return aMap
with one of the result's columns as key and the corresponding records as value.java.util.Map<Record,R>
intoMap(int[] keyFieldIndexes)
Return aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given keys and mapped by the given mapper.java.util.Map<?,?>
intoMap(int keyFieldIndex, int valueFieldIndex)
Return aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given key and mapped by the given mapper.java.util.Map<Record,R>
intoMap(Field<?>[] keys)
Return aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given keys and mapped by the given mapper.<K> java.util.Map<K,R>
intoMap(Field<K> key)
Return aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given key and mapped by the given mapper.java.util.Map<?,R>
intoMap(Name keyFieldName)
Return aMap
with one of the result's columns as key and the corresponding records as value.java.util.Map<Record,R>
intoMap(Name[] keyFieldNames)
Return aMap
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 aMap
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 aMap
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 aMap
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 aMap
with results grouped by the given key and mapped into the given entity type.java.util.Map<?,?>
intoMap(Name keyFieldName, Name valueFieldName)
Return aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 aMap
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 JDBCResultSet
containing the data of thisResult
.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 thisResult
.boolean
isNotEmpty()
Whether there are any records contained in thisResult
.<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 org.jooq.Attachable
configuration
-
Methods inherited from interface org.jooq.Formattable
format, format, format, format, format, format, format, format, format, formatChart, formatChart, formatChart, formatChart, formatChart, formatChart, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatCSV, formatHTML, formatHTML, formatHTML, formatInsert, formatInsert, formatInsert, formatInsert, formatInsert, formatInsert, formatJSON, formatJSON, formatJSON, formatJSON, formatJSON, formatJSON, formatXML, formatXML, formatXML, formatXML, formatXML, formatXML, intoXML, intoXML, intoXML, intoXML
-
-
-
-
Method Detail
-
recordType
RecordType<R> recordType()
Get this result's record type.
-
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.
- 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 totype
.- See Also:
Row.field(String, Class)
-
field
<T> Field<T> field(java.lang.String name, DataType<T> dataType)
Get a specific field from this Result, coerced todataType
.- See Also:
Row.field(String, DataType)
-
field
Field<?> field(Name name)
Get a specific field from this Result.- See Also:
Row.field(Name)
-
field
<T> Field<T> field(Name name, java.lang.Class<T> type)
Get a specific field from this Result, coerced totype
.- See Also:
Row.field(Name, Class)
-
field
<T> Field<T> field(Name name, DataType<T> dataType)
Get a specific field from this Result, coerced todataType
.- See Also:
Row.field(Name, DataType)
-
field
Field<?> field(int index)
Get a specific field from this Result.- See Also:
Row.field(int)
-
field
<T> Field<T> field(int index, java.lang.Class<T> type)
Get a specific field from this Result, coerced totype
.- See Also:
Row.field(int, Class)
-
field
<T> Field<T> field(int index, DataType<T> dataType)
Get a specific field from this Result, coerced todataType
.- See Also:
Row.field(int, DataType)
-
fields
Field<?>[] fields()
Get all fields from this Result.- See Also:
Row.fields()
-
fields
Field<?>[] fields(Field<?>... fields)
Get all fields from this Result, providing some fields.- Returns:
- All available fields
- See Also:
Row.fields(Field...)
-
fields
Field<?>[] fields(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 indexfield
- 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 infieldsRow()
-
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.0Convenience 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 indexfield
- The value's fielddefaultValue
- The default value if the value wasnull
- 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 infieldsRow()
-
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 indexfieldIndex
- 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 infieldsRow()
-
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.0Convenience method to fetch a value at a given position in the result.- Parameters:
index
- The record's indexfieldIndex
- The value's field indexdefaultValue
- The default value if the value wasnull
- 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 infieldsRow()
-
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 indexfieldName
- 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 infieldsRow()
-
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.0Convenience method to fetch a value at a given position in the result.- Parameters:
index
- The record's indexfieldName
- The value's field namedefaultValue
- The default value if the value wasnull
- 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 infieldsRow()
-
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 infieldsRow()
-
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' fieldtype
- The type used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
- 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' fieldconverter
- The data type converter used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
- 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 infieldsRow()
-
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 indextype
- The type used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument fieldIndex is not contained infieldsRow()
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 indexconverter
- The data type converter used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument fieldIndex is not contained infieldsRow()
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 infieldsRow()
-
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 nametype
- The type used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
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 nameconverter
- The data type converter used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
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 infieldsRow()
-
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 nametype
- The type used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
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 nameconverter
- The data type converter used for type conversion- Returns:
- The values
- Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
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 thisResult
.
-
isNotEmpty
boolean isNotEmpty()
Whether there are any records contained in thisResult
.
-
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
with one of the result's columns as key and another one of the result's columns as valueAn
InvalidResultException
is thrown, if the key turns out to be non-unique in the result set. UseintoGroups(Field, Field)
instead, if your keys are non-unique- Type Parameters:
K
- The key's generic field typeV
- 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 infieldsRow()
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 aMap
with one of the result's columns as key and another one of the result's columns as valueAn
InvalidResultException
is thrown, if the key turns out to be non-unique in the result set. UseintoGroups(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 infieldsRow()
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 aMap
with one of the result's columns as key and another one of the result's columns as valueAn
InvalidResultException
is thrown, if the key turns out to be non-unique in the result set. UseintoGroups(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 infieldsRow()
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 aMap
with one of the result's columns as key and another one of the result's columns as valueAn
InvalidResultException
is thrown, if the key turns out to be non-unique in the result set. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
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. UseintoGroups(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 isnull
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 infieldsRow()
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 aMap
with results grouped by the given key entity.The grouping semantics is governed by the key type's
Object.equals(Object)
andObject.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. UseintoGroups(Class)
instead, if your keys are non-unique.- Parameters:
keyType
- The key type. If this isnull
, 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 recordsInvalidResultException
- 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 aMap
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)
andObject.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. UseintoGroups(Class, Class)
instead, if your keys are non-unique.- Parameters:
keyType
- The key type. If this isnull
, 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 recordsInvalidResultException
- 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 aMap
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)
andObject.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. UseintoGroups(Class, RecordMapper)
instead, if your keys are non-unique.- Parameters:
keyType
- The key type. If this isnull
, 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 recordsInvalidResultException
- 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 aMap
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)
andObject.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. UseintoGroups(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 recordsInvalidResultException
- 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 aMap
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)
andObject.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. UseintoGroups(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 recordsInvalidResultException
- 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 aMap
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)
andObject.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. UseintoGroups(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 recordsInvalidResultException
- 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 aMap
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. UseintoGroups(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 benull
.- Returns:
- A Map containing the results.
- Throws:
java.lang.IllegalArgumentException
- If any of the argument fields is not contained infieldsRow()
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 aMap
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. UseintoGroups(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 benull
.valueTable
- The value table. May not benull
.- Returns:
- A Map containing the results.
- Throws:
java.lang.IllegalArgumentException
- If any of the argument fields is not contained infieldsRow()
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 aMap
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. UseintoGroups(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 benull
.type
- The entity type.- Returns:
- A Map containing the results.
- Throws:
java.lang.IllegalArgumentException
- If any of the argument fields is not contained infieldsRow()
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 aMap
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. UseintoGroups(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 benull
.mapper
- The mapper callback.- Returns:
- A Map containing the results.
- Throws:
java.lang.IllegalArgumentException
- If any of the argument fields is not contained infieldsRow()
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 aMap
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 infieldsRow()
-
intoGroups
java.util.Map<?,Result<R>> intoGroups(int keyFieldIndex) throws java.lang.IllegalArgumentException
Return aMap
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 infieldsRow()
-
intoGroups
java.util.Map<?,Result<R>> intoGroups(java.lang.String keyFieldName) throws java.lang.IllegalArgumentException
Return aMap
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 infieldsRow()
-
intoGroups
java.util.Map<?,Result<R>> intoGroups(Name keyFieldName) throws java.lang.IllegalArgumentException
Return aMap
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 infieldsRow()
-
intoGroups
<K,V> java.util.Map<K,java.util.List<V>> intoGroups(Field<K> key, Field<V> value) throws java.lang.IllegalArgumentException
Return aMap
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 typeV
- 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 infieldsRow()
-
intoGroups
java.util.Map<?,java.util.List<?>> intoGroups(int keyFieldIndex, int valueFieldIndex) throws java.lang.IllegalArgumentException
Return aMap
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 infieldsRow()
-
intoGroups
java.util.Map<?,java.util.List<?>> intoGroups(java.lang.String keyFieldName, java.lang.String valueFieldName) throws java.lang.IllegalArgumentException
Return aMap
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 infieldsRow()
-
intoGroups
java.util.Map<?,java.util.List<?>> intoGroups(Name keyFieldName, Name valueFieldName) throws java.lang.IllegalArgumentException
Return aMap
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 infieldsRow()
-
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 aMap
with results grouped by the given key and mapped into the given entity type.- Type Parameters:
K
- The key's generic field typeE
- The generic entity type.- Parameters:
key
- The key field.type
- The entity type.- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
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 aMap
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 infieldsRow()
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 aMap
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 infieldsRow()
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 aMap
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 infieldsRow()
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 aMap
with results grouped by the given key and mapped by the given mapper.- Type Parameters:
K
- The key's generic field typeE
- The generic entity type.- Parameters:
key
- The key field.mapper
- The mapper callback.- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
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 aMap
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 infieldsRow()
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 aMap
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 infieldsRow()
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 aMap
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<R>> intoGroups(int[] keyFieldIndexes) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<R>> intoGroups(java.lang.String[] keyFieldNames) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<R>> intoGroups(Name[] keyFieldNames) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<Record>> intoGroups(Field<?>[] keys, Field<?>[] values) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<Record>> intoGroups(int[] keyFieldIndexes, int[] valueFieldIndexes) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<Record>> intoGroups(java.lang.String[] keyFieldNames, java.lang.String[] valueFieldNames) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
intoGroups
java.util.Map<Record,Result<Record>> intoGroups(Name[] keyFieldNames, Name[] valueFieldNames) throws java.lang.IllegalArgumentException
Return aMap
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 isnull
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 infieldsRow()
-
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
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 isnull
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 infieldsRow()
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 aMap
with results grouped by the given key entity.The grouping semantics is governed by the key type's
Object.equals(Object)
andObject.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 isnull
, 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 aMap
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)
andObject.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 isnull
, 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 aMap
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)
andObject.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 isnull
, 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 aMap
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)
andObject.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 aMap
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)
andObject.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 aMap
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)
andObject.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 aMap
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 benull
.- Returns:
- A Map containing grouped results
- Throws:
java.lang.IllegalArgumentException
- If any of the argument fields is not contained infieldsRow()
-
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 aMap
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 benull
.valueTable
- The value table. May not benull
.- Returns:
- A Map containing grouped results
- Throws:
java.lang.IllegalArgumentException
- If any of the argument fields is not contained infieldsRow()
-
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 aMap
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 benull
.type
- The entity type.- Returns:
- A Map containing grouped results
- Throws:
java.lang.IllegalArgumentException
- If the any of the argument fields is not contained infieldsRow()
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 aMap
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 benull
.mapper
- The mapper callback.- Returns:
- A Map containing grouped results
- Throws:
java.lang.IllegalArgumentException
- If the any of the argument fields is not contained infieldsRow()
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] - UseintoArrays()
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 aboutfieldIndex
's actual type. - Throws:
java.lang.IllegalArgumentException
- If the argument fieldIndex is not contained infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 aboutfieldName
's actual type. - Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 aboutfieldName
's actual type. - Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 aboutfieldIndex
's actual type. - Throws:
java.lang.IllegalArgumentException
- If the argument fieldIndex is not contained infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 aboutfieldName
's actual type. - Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 aboutfieldName
's actual type. - Throws:
java.lang.IllegalArgumentException
- If the argument fieldName is not contained infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 infieldsRow()
- 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 infieldsRow()
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 infieldsRow()
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 thisResult
. SeeRecord.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 thisResult
. SeeRecord.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 JDBCResultSet
containing the data of thisResult
.Use this as an adapter for JDBC-compliant code that expects a
ResultSet
to operate on, rather than a jOOQResult
. The returnedResultSet
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 thisResultSet
, as the underlyingResult
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 theResultSet
's scrolling methods, e.g.ResultSet.next()
orResultSet.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 infieldsRow()
-
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 infieldsRow()
-
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 infieldsRow()
-
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 infieldsRow()
-
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 infieldsRow()
-
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 infieldsRow()
-
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 infieldsRow()
-
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 infieldsRow()
-
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 suppliedcomparator
.- Parameters:
field
- The sort fieldcomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
field
- The sort fieldcomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
fieldIndex
- The sort field indexcomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
fieldIndex
- The sort field indexcomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
fieldName
- The sort field namecomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
fieldName
- The sort field namecomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
fieldName
- The sort field namecomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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 suppliedcomparator
.- Parameters:
fieldName
- The sort field namecomparator
- The comparator used to sort this result.- Returns:
- The result itself
- Throws:
java.lang.IllegalArgumentException
- If the argument field is not contained infieldsRow()
-
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.0Specify 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.0Specify 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 aResult
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.0Specify 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.0Specify a set of field names whose values should be interned.See
intern(int...)
for more details.- Parameters:
fieldNames
- The field names whose values should be interned- Returns:
- The same result
- See Also:
intern(Field...)
,String.intern()
-
fetchParents
<O extends UpdatableRecord<O>> Result<O> fetchParents(ForeignKey<R,O> key) throws DataAccessException
Fetch parent records of this record, given a foreign key.- Throws:
DataAccessException
- if something went wrong executing the query.- See Also:
ForeignKey.fetchParent(Record)
,ForeignKey.fetchParents(java.util.Collection)
,ForeignKey.fetchParents(Record...)
-
fetchChildren
<O extends TableRecord<O>> Result<O> fetchChildren(ForeignKey<O,R> key) throws DataAccessException
Fetch child records of this record, given a foreign key.- Throws:
DataAccessException
- if something went wrong executing the query.- See Also:
ForeignKey.fetchChildren(java.util.Collection)
,ForeignKey.fetchChildren(Record)
,ForeignKey.fetchChildren(Record...)
-
attach
void attach(Configuration configuration)
Attach this result and all of its contained records to a newConfiguration
.- Specified by:
attach
in interfaceAttachable
- Parameters:
configuration
- A configuration ornull
, if you wish to detach thisAttachable
from its previous configuration.
-
detach
void detach()
Detach this result and all of its contained records from their currentConfiguration
.This is the same as calling
attach(null)
.- Specified by:
detach
in interfaceAttachable
-
-