Module org.jooq
Package org.jooq

Interface ResultQuery<R extends Record>

All Superinterfaces:
Attachable, AttachableQueryPart, AutoCloseable, Fields, Flow.Publisher<R>, Iterable<R>, Publisher<R>, org.reactivestreams.Publisher<R>, Query, QueryPart, Serializable, Statement
All Known Subinterfaces:
DeleteResultStep<R>, InsertResultStep<R>, Select<R>, SelectConditionStep<R>, SelectConnectByAfterStartWithConditionStep<R>, SelectConnectByConditionStep<R>, SelectConnectByStep<R>, SelectCorrelatedSubqueryStep<R>, SelectDistinctOnStep<R>, SelectFinalStep<R>, SelectForJSONCommonDirectivesStep<R>, SelectForStep<R>, SelectForUpdateOfStep<R>, SelectForUpdateStep<R>, SelectForUpdateWaitStep<R>, SelectForXMLCommonDirectivesStep<R>, SelectForXMLPathDirectivesStep<R>, SelectForXMLRawDirectivesStep<R>, SelectFromStep<R>, SelectGroupByStep<R>, SelectHavingConditionStep<R>, SelectHavingStep<R>, SelectIntoStep<R>, SelectJoinStep<R>, SelectLimitAfterOffsetStep<R>, SelectLimitPercentAfterOffsetStep<R>, SelectLimitPercentStep<R>, SelectLimitStep<R>, SelectOffsetStep<R>, SelectOnConditionStep<R>, SelectOptionalOnStep<R>, SelectOptionStep<R>, SelectOrderByStep<R>, SelectQualifyConditionStep<R>, SelectQualifyStep<R>, SelectQuery<R>, SelectSeekLimitStep<R>, SelectSeekStep1<R,T1>, SelectSeekStep10<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>, SelectSeekStep11<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>, SelectSeekStep12<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>, SelectSeekStep13<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>, SelectSeekStep14<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>, SelectSeekStep15<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>, SelectSeekStep16<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>, SelectSeekStep17<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>, SelectSeekStep18<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>, SelectSeekStep19<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>, SelectSeekStep2<R,T1,T2>, SelectSeekStep20<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>, SelectSeekStep21<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>, SelectSeekStep22<R,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>, SelectSeekStep3<R,T1,T2,T3>, SelectSeekStep4<R,T1,T2,T3,T4>, SelectSeekStep5<R,T1,T2,T3,T4,T5>, SelectSeekStep6<R,T1,T2,T3,T4,T5,T6>, SelectSeekStep7<R,T1,T2,T3,T4,T5,T6,T7>, SelectSeekStep8<R,T1,T2,T3,T4,T5,T6,T7,T8>, SelectSeekStep9<R,T1,T2,T3,T4,T5,T6,T7,T8,T9>, SelectSeekStepN<R>, SelectSelectStep<R>, SelectStartWithStep<R>, SelectUnionStep<R>, SelectWhereStep<R>, SelectWindowStep<R>, SelectWithTiesAfterOffsetStep<R>, SelectWithTiesStep<R>, UpdateResultStep<R>
public interface ResultQuery<R extends Record> extends Fields, Query, Iterable<R>, Publisher<R>
A query that can return results.

jOOQ distinguishes between ordinary Query types, such as Insert, Update, Delete, and any DDLQuery, which are meant to produce side effects in a database, and the ResultQuery, which is meant to produce a Result through various means.

The most common way to create a result is by calling fetch(), or by using the query's iterator() method in a foreach loop: 


 Result<TRecord> result = ctx.select(T.A, T.B).from(T).fetch();

 for (TRecord record : ctx.select(T.A, T.B).from(T)) {
   // ...
 }

Most approaches to fetching results in ResultQuery (including the above), fetch the entire JDBC ResultSet eagerly into memory, which allows for closing the underlying JDBC resources as quickly as possible. Such operations are not resourceful, i.e. users do not need to worry about closing any resources. None of the many ways of fetching data will affect the SQL query projection (SELECT clause). Hence, users must make sure not to fetch any unnecessary columns, themselves.

There are, however, some ways of fetching results lazily, and thus in a resourceful way. These include:

  • fetchLazy() and related methods, which produce a Cursor for imperative style consumption of resulting records.
  • fetchStream() and related methods, which produce a Java Stream for functional style consumption of resulting records.

In both cases, it is recommended to explicitly close the underlying resources (i.e. JDBC ResultSet) using try-with-resources: 


 try (Cursor<TRecord> cursor = ctx.select(T.A, T.B).from(T).fetchLazy()) {
   for (;;) {
     TRecord record = cursor.fetchNext();
     if (record == null)
       break;

     // ...
   }
 }

 try (Stream<TRecord> stream = ctx.select(T.A, T.B).from(T).fetchStream()) {
   stream.forEach(record -> {
     // ...
   });
 }

While most instances of ResultQuery implement Select, there also exist other types of ResultQuery constructed e.g. from plain SQL APIs, such as DSLContext.resultQuery(String).

Author:
Lukas Eder

  • Method Summary

    Modifier and Type
    Method
    Description
    @NotNull ResultQuery<R>
    bind(int index, Object value)
    Bind a new value to an indexed parameter.
    @NotNull ResultQuery<R>
    bind(String param, Object value)
    Bind a new value to a named parameter.
    @NotNull ResultQuery<Record>
    coerce(Collection<? extends Field<?>> fields)
    Coerce the result record type of this query to that of a set of fields.
    @NotNull ResultQuery<Record>
    coerce(Field<?>... fields)
    Coerce the result record type of this query to that of a set of fields.
    <T1> @NotNull ResultQuery<Record1<T1>>
    coerce(Field<T1> field1)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2> @NotNull ResultQuery<Record2<T1,T2>>
    coerce(Field<T1> field1, Field<T2> field2)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3> @NotNull ResultQuery<Record3<T1,T2,T3>>
    coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4>
    @NotNull ResultQuery<Record4<T1,T2,T3,T4>>
    coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5>
    @NotNull ResultQuery<Record5<T1,T2,T3,T4,T5>>
    coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6>
    @NotNull ResultQuery<Record6<T1,T2,T3,T4,T5,T6>>
    coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7>
    @NotNull ResultQuery<Record7<T1,T2,T3,T4,T5,T6,T7>>
    coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8>
    @NotNull ResultQuery<Record8<T1,T2,T3,T4,T5,T6,T7,T8>>
    coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9>
    @NotNull ResultQuery<Record9<T1,T2,T3,T4,T5,T6,T7,T8,T9>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
    @NotNull ResultQuery<Record10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
    @NotNull ResultQuery<Record11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
    @NotNull ResultQuery<Record12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
    @NotNull ResultQuery<Record13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
    @NotNull ResultQuery<Record14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
    @NotNull ResultQuery<Record15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
    @NotNull ResultQuery<Record16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
    @NotNull ResultQuery<Record17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
    @NotNull ResultQuery<Record18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
    @NotNull ResultQuery<Record19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
    @NotNull ResultQuery<Record20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
    @NotNull ResultQuery<Record21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
    @NotNull ResultQuery<Record22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>>
    coerce(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)
    Coerce the result record type of this query to that of a set of fields.
    <X extends Record>
    @NotNull ResultQuery<X>
    coerce(Table<X> table)
    Coerce the result record type of this query to that of a table.
    <X, A> X
    collect(Collector<? super R,A,X> collector)
    Reduce the execution results of this query using a Collector.
    @NotNull Result<R>
    fetch()
    Execute the query and return the generated result.
    @NotNull List<?>
    fetch(int fieldIndex)
    Execute the query and return all values for a field index from the generated result.
    <U> @NotNull List<U>
    fetch(int fieldIndex, Class<? extends U> type)
    Execute the query and return all values for a field index from the generated result.
    <U> @NotNull List<U>
    fetch(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return all values for a field index from the generated result.
    @NotNull List<?>
    fetch(String fieldName)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull List<U>
    fetch(String fieldName, Class<? extends U> type)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull List<U>
    fetch(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull List<U>
    fetch(Field<?> field, Class<? extends U> type)
    Execute the query and return all values for a field from the generated result.
    <T> @NotNull List<T>
    fetch(Field<T> field)
    Execute the query and return all values for a field from the generated result.
    <T, U> @NotNull List<U>
    fetch(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return all values for a field from the generated result.
    @NotNull List<?>
    fetch(Name fieldName)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull List<U>
    fetch(Name fieldName, Class<? extends U> type)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull List<U>
    fetch(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return all values for a field name from the generated result.
    <E> @NotNull List<E>
    fetch(RecordMapper<? super R,E> mapper)
    Fetch results into a custom mapper callback.
    R
    fetchAny()
    Execute the query and return at most one resulting record.
    @Nullable Object
    fetchAny(int fieldIndex)
    Execute the query and return at most one resulting value for a field index from the generated result.
    <U> U
    fetchAny(int fieldIndex, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field index from the generated result.
    <U> U
    fetchAny(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field index from the generated result.
    @Nullable Object
    fetchAny(String fieldName)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchAny(String fieldName, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchAny(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchAny(Field<?> field, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field from the generated result.
    <T> T
    fetchAny(Field<T> field)
    Execute the query and return at most one resulting value for a field from the generated result.
    <T, U> U
    fetchAny(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return at most one resulting value for a field from the generated result.
    @Nullable Object
    fetchAny(Name fieldName)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchAny(Name fieldName, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchAny(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <E> E
    fetchAny(RecordMapper<? super R,E> mapper)
    Execute the query and return at most one resulting record.
    @Nullable Object @Nullable []
    fetchAnyArray()
    Execute the query and return at most one resulting record as an array
    <E> E
    fetchAnyInto(Class<? extends E> type)
    Map resulting records onto a custom type.
    <Z extends Record>
    Z
    fetchAnyInto(Table<Z> table)
    Map resulting records onto a custom record.
    @Nullable Map<String,Object>
    fetchAnyMap()
    Execute the query and return at most one resulting record as a name/value map.
    @NotNull R @NotNull []
    fetchArray()
    Execute the query and return the generated result as an array of records.
    @Nullable Object @NotNull []
    fetchArray(int fieldIndex)
    Execute the query and return all values for a field index from the generated result.
    <U> U @NotNull []
    fetchArray(int fieldIndex, Class<? extends U> type)
    Execute the query and return all values for a field index from the generated result.
    <U> U @NotNull []
    fetchArray(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return all values for a field index from the generated result.
    @Nullable Object @NotNull []
    fetchArray(String fieldName)
    Execute the query and return all values for a field name from the generated result.
    <U> U @NotNull []
    fetchArray(String fieldName, Class<? extends U> type)
    Execute the query and return all values for a field name from the generated result.
    <U> U @NotNull []
    fetchArray(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return all values for a field name from the generated result.
    <U> U @NotNull []
    fetchArray(Field<?> field, Class<? extends U> type)
    Execute the query and return all values for a field from the generated result.
    <T> T @NotNull []
    fetchArray(Field<T> field)
    Execute the query and return all values for a field from the generated result.
    <T, U> U @NotNull []
    fetchArray(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return all values for a field from the generated result.
    @Nullable Object @NotNull []
    fetchArray(Name fieldName)
    Execute the query and return all values for a field name from the generated result.
    <U> U @NotNull []
    fetchArray(Name fieldName, Class<? extends U> type)
    Execute the query and return all values for a field name from the generated result.
    <U> U @NotNull []
    fetchArray(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return all values for a field name from the generated result.
    @Nullable Object @NotNull [] @NotNull []
    fetchArrays()
    Execute the query and return the generated result as an Object matrix.
    @NotNull CompletionStage<Result<R>>
    fetchAsync()
    Fetch results in a new CompletionStage.
    @NotNull CompletionStage<Result<R>>
    fetchAsync(Executor executor)
    Fetch results in a new CompletionStage that is asynchronously completed by a task running in the given executor.
    @NotNull Map<?,Result<R>>
    fetchGroups(int keyFieldIndex)
    Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
    @NotNull Map<Record,Result<R>>
    fetchGroups(int[] keyFieldIndexes)
    Execute the query and return a Map with the result grouped by the given keys.
    @NotNull Map<Record,Result<Record>>
    fetchGroups(int[] keyFieldIndexes, int[] valueFieldIndexes)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(int[] keyFieldIndexes, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(int[] keyFieldIndexes, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    @NotNull Map<?,List<?>>
    fetchGroups(int keyFieldIndex, int valueFieldIndex)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <E> @NotNull Map<?,List<E>>
    fetchGroups(int keyFieldIndex, Class<? extends E> type)
    Return a Map with results grouped by the given key and mapped into the given entity type.
    <E> @NotNull Map<?,List<E>>
    fetchGroups(int keyFieldIndex, RecordMapper<? super R,E> mapper)
    Return a Map with results grouped by the given key and mapped by the given mapper.
    <K> @NotNull Map<K,Result<R>>
    fetchGroups(Class<? extends K> keyType)
    Execute the query and return a Map with results grouped by the given key entity.
    <K, V> @NotNull Map<K,List<V>>
    fetchGroups(Class<? extends K> keyType, Class<? extends V> valueType)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <K, V> @NotNull Map<K,List<V>>
    fetchGroups(Class<? extends K> keyType, RecordMapper<? super R,V> valueMapper)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    @NotNull Map<?,Result<R>>
    fetchGroups(String keyFieldName)
    Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
    @NotNull Map<Record,Result<R>>
    fetchGroups(String[] keyFieldNames)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(String[] keyFieldNames, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    @NotNull Map<Record,Result<Record>>
    fetchGroups(String[] keyFieldNames, String[] valueFieldNames)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(String[] keyFieldNames, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    <E> @NotNull Map<?,List<E>>
    fetchGroups(String keyFieldName, Class<? extends E> type)
    Return a Map with results grouped by the given key and mapped into the given entity type.
    @NotNull Map<?,List<?>>
    fetchGroups(String keyFieldName, String valueFieldName)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <E> @NotNull Map<?,List<E>>
    fetchGroups(String keyFieldName, RecordMapper<? super R,E> mapper)
    Return a Map with results grouped by the given key and mapped by the given mapper.
    @NotNull Map<Record,Result<R>>
    fetchGroups(Field<?>[] keys)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(Field<?>[] keys, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    @NotNull Map<Record,Result<Record>>
    fetchGroups(Field<?>[] keys, Field<?>[] values)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(Field<?>[] keys, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    <K> @NotNull Map<K,Result<R>>
    fetchGroups(Field<K> key)
    Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
    <K, E> @NotNull Map<K,List<E>>
    fetchGroups(Field<K> key, Class<? extends E> type)
    Return a Map with results grouped by the given key and mapped into the given entity type.
    <K, V> @NotNull Map<K,List<V>>
    fetchGroups(Field<K> key, Field<V> value)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <K, E> @NotNull Map<K,List<E>>
    fetchGroups(Field<K> key, RecordMapper<? super R,E> mapper)
    Return a Map with results grouped by the given key and mapped by the given mapper.
    @NotNull Map<?,Result<R>>
    fetchGroups(Name keyFieldName)
    Execute the query and return a Map with one of the result's columns as key and a list of corresponding records as value.
    @NotNull Map<Record,Result<R>>
    fetchGroups(Name[] keyFieldNames)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(Name[] keyFieldNames, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    @NotNull Map<Record,Result<Record>>
    fetchGroups(Name[] keyFieldNames, Name[] valueFieldNames)
    Execute the query and return a Map with the result grouped by the given keys.
    <E> @NotNull Map<Record,List<E>>
    fetchGroups(Name[] keyFieldNames, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    <E> @NotNull Map<?,List<E>>
    fetchGroups(Name keyFieldName, Class<? extends E> type)
    Return a Map with results grouped by the given key and mapped into the given entity type.
    @NotNull Map<?,List<?>>
    fetchGroups(Name keyFieldName, Name valueFieldName)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <E> @NotNull Map<?,List<E>>
    fetchGroups(Name keyFieldName, RecordMapper<? super R,E> mapper)
    Return a Map with results grouped by the given key and mapped by the given mapper.
    <K> @NotNull Map<K,Result<R>>
    fetchGroups(RecordMapper<? super R,K> keyMapper)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <K, V> @NotNull Map<K,List<V>>
    fetchGroups(RecordMapper<? super R,K> keyMapper, Class<V> valueType)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <K, V> @NotNull Map<K,List<V>>
    fetchGroups(RecordMapper<? super R,K> keyMapper, RecordMapper<? super R,V> valueMapper)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <S extends Record>
    @NotNull Map<S,Result<R>>
    fetchGroups(Table<S> table)
    Execute the query and return a Map with the result grouped by the given table.
    <E, S extends Record>
    @NotNull Map<S,List<E>>
    fetchGroups(Table<S> table, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given table and mapped into the given entity type.
    <E, S extends Record>
    @NotNull Map<S,List<E>>
    fetchGroups(Table<S> table, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given table and mapped by the given mapper.
    <S extends Record, T extends Record>
    @NotNull Map<S,Result<T>>
    fetchGroups(Table<S> keyTable, Table<T> valueTable)
    Execute the query and return a Map with the result grouped by the given table.
    <H extends RecordHandler<? super R>>
    H
    fetchInto(H handler)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.15.0 - [#11902] - Use Iterable.forEach(Consumer) based methods, instead.
    <E> @NotNull List<E>
    fetchInto(Class<? extends E> type)
    Map resulting records onto a custom type.
    <Z extends Record>
    @NotNull Result<Z>
    fetchInto(Table<Z> table)
    Map resulting records onto a custom record.
    @NotNull Cursor<R>
    fetchLazy()
    Execute the query and "lazily" return the generated result.
    @NotNull Results
    fetchMany()
    Execute a query, possibly returning several result sets.
    @NotNull Map<?,R>
    fetchMap(int keyFieldIndex)
    Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
    @NotNull Map<Record,R>
    fetchMap(int[] keyFieldIndexes)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    @NotNull Map<Record,Record>
    fetchMap(int[] keyFieldIndexes, int[] valueFieldIndexes)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(int[] keyFieldIndexes, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    <E> @NotNull Map<List<?>,E>
    fetchMap(int[] keyFieldIndexes, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    @NotNull Map<?,?>
    fetchMap(int keyFieldIndex, int valueFieldIndex)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <E> @NotNull Map<?,E>
    fetchMap(int keyFieldIndex, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
    <E> @NotNull Map<?,E>
    fetchMap(int keyFieldIndex, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
    <K> @NotNull Map<K,R>
    fetchMap(Class<? extends K> keyType)
    Execute the query and return a Map with results grouped by the given key entity.
    <K, V> @NotNull Map<K,V>
    fetchMap(Class<? extends K> keyType, Class<? extends V> valueType)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <K, V> @NotNull Map<K,V>
    fetchMap(Class<? extends K> keyType, RecordMapper<? super R,V> valueMapper)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    @NotNull Map<?,R>
    fetchMap(String keyFieldName)
    Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
    @NotNull Map<Record,R>
    fetchMap(String[] keyFieldNames)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(String[] keyFieldNames, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    @NotNull Map<Record,Record>
    fetchMap(String[] keyFieldNames, String[] valueFieldNames)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(String[] keyFieldNames, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    <E> @NotNull Map<?,E>
    fetchMap(String keyFieldName, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
    @NotNull Map<?,?>
    fetchMap(String keyFieldName, String valueFieldName)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <E> @NotNull Map<?,E>
    fetchMap(String keyFieldName, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
    @NotNull Map<Record,R>
    fetchMap(Field<?>[] keys)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(Field<?>[] keys, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    @NotNull Map<Record,Record>
    fetchMap(Field<?>[] keys, Field<?>[] values)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(Field<?>[] keys, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    <K> @NotNull Map<K,R>
    fetchMap(Field<K> key)
    Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
    <K, E> @NotNull Map<K,E>
    fetchMap(Field<K> key, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
    <K, V> @NotNull Map<K,V>
    fetchMap(Field<K> key, Field<V> value)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <K, E> @NotNull Map<K,E>
    fetchMap(Field<K> key, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
    @NotNull Map<?,R>
    fetchMap(Name keyFieldName)
    Execute the query and return a Map with one of the result's columns as key and the corresponding records as value.
    @NotNull Map<Record,R>
    fetchMap(Name[] keyFieldNames)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(Name[] keyFieldNames, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given keys and mapped into the given entity type.
    @NotNull Map<Record,Record>
    fetchMap(Name[] keyFieldNames, Name[] valueFieldNames)
    Execute the query and return a Map with keys as a map key and the corresponding record as value.
    <E> @NotNull Map<List<?>,E>
    fetchMap(Name[] keyFieldNames, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given keys and mapped by the given mapper.
    <E> @NotNull Map<?,E>
    fetchMap(Name keyFieldName, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given key and mapped into the given entity type.
    @NotNull Map<?,?>
    fetchMap(Name keyFieldName, Name valueFieldName)
    Execute the query and return a Map with one of the result's columns as key and another one of the result's columns as value
    <E> @NotNull Map<?,E>
    fetchMap(Name keyFieldName, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given key and mapped by the given mapper.
    <K> @NotNull Map<K,R>
    fetchMap(RecordMapper<? super R,K> keyMapper)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <K, V> @NotNull Map<K,V>
    fetchMap(RecordMapper<? super R,K> keyMapper, Class<V> valueType)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <K, V> @NotNull Map<K,V>
    fetchMap(RecordMapper<? super R,K> keyMapper, RecordMapper<? super R,V> valueMapper)
    Execute the query and return a Map with results grouped by the given key entity and mapped into the given entity type.
    <S extends Record>
    @NotNull Map<S,R>
    fetchMap(Table<S> table)
    Execute the query and return a Map with table as a map key and the corresponding record as value.
    <E, S extends Record>
    @NotNull Map<S,E>
    fetchMap(Table<S> table, Class<? extends E> type)
    Execute the query and return a Map with results grouped by the given table and mapped into the given entity type.
    <E, S extends Record>
    @NotNull Map<S,E>
    fetchMap(Table<S> table, RecordMapper<? super R,E> mapper)
    Execute the query and return a Map with results grouped by the given table and mapped by the given mapper.
    <S extends Record, T extends Record>
    @NotNull Map<S,T>
    fetchMap(Table<S> keyTable, Table<T> valueTable)
    Execute the query and return a Map with table as a map key and the corresponding record as value.
    @NotNull List<Map<String,Object>>
    fetchMaps()
    Execute the query and return the generated result as a list of name/value maps.
    R
    fetchOne()
    Execute the query and return at most one resulting record.
    @Nullable Object
    fetchOne(int fieldIndex)
    Execute the query and return at most one resulting value for a field index from the generated result.
    <U> U
    fetchOne(int fieldIndex, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field index from the generated result.
    <U> U
    fetchOne(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field index from the generated result.
    @Nullable Object
    fetchOne(String fieldName)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchOne(String fieldName, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchOne(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchOne(Field<?> field, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field from the generated result.
    <T> T
    fetchOne(Field<T> field)
    Execute the query and return at most one resulting value for a field from the generated result.
    <T, U> U
    fetchOne(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return at most one resulting value for a field from the generated result.
    @Nullable Object
    fetchOne(Name fieldName)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchOne(Name fieldName, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> U
    fetchOne(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <E> E
    fetchOne(RecordMapper<? super R,E> mapper)
    Execute the query and return at most one resulting value into a custom mapper callback.
    @Nullable Object @Nullable []
    fetchOneArray()
    Execute the query and return at most one resulting record as an array
    <E> E
    fetchOneInto(Class<? extends E> type)
    Map resulting records onto a custom type.
    <Z extends Record>
    Z
    fetchOneInto(Table<Z> table)
    Map resulting records onto a custom record.
    @Nullable Map<String,Object>
    fetchOneMap()
    Execute the query and return at most one resulting record as a name/value map.
    @NotNull Optional<R>
    fetchOptional()
    Execute the query and return at most one resulting record.
    @NotNull Optional<?>
    fetchOptional(int fieldIndex)
    Execute the query and return at most one resulting value for a field index from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(int fieldIndex, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field index from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field index from the generated result.
    @NotNull Optional<?>
    fetchOptional(String fieldName)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(String fieldName, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(Field<?> field, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field from the generated result.
    <T> @NotNull Optional<T>
    fetchOptional(Field<T> field)
    Execute the query and return at most one resulting value for a field from the generated result.
    <T, U> @NotNull Optional<U>
    fetchOptional(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return at most one resulting value for a field from the generated result.
    @NotNull Optional<?>
    fetchOptional(Name fieldName)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(Name fieldName, Class<? extends U> type)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <U> @NotNull Optional<U>
    fetchOptional(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return at most one resulting value for a field name from the generated result.
    <E> @NotNull Optional<E>
    fetchOptional(RecordMapper<? super R,E> mapper)
    Execute the query and return at most one resulting value into a custom mapper callback.
    @NotNull Optional<Object[]>
    fetchOptionalArray()
    Execute the query and return at most one resulting record as an array.
    <E> @NotNull Optional<E>
    fetchOptionalInto(Class<? extends E> type)
    Map resulting records onto a custom type.
    <Z extends Record>
    @NotNull Optional<Z>
    fetchOptionalInto(Table<Z> table)
    Map resulting records onto a custom record.
    @NotNull Optional<Map<String,Object>>
    fetchOptionalMap()
    Execute the query and return at most one resulting record as a name/value map.
    @NotNull ResultSet
    fetchResultSet()
    Execute the query and return the generated result as a JDBC ResultSet.
    @NotNull Set<?>
    fetchSet(int fieldIndex)
    Execute the query and return all values for a field index from the generated result.
    <U> @NotNull Set<U>
    fetchSet(int fieldIndex, Class<? extends U> type)
    Execute the query and return all values for a field index from the generated result.
    <U> @NotNull Set<U>
    fetchSet(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return all values for a field index from the generated result.
    @NotNull Set<?>
    fetchSet(String fieldName)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull Set<U>
    fetchSet(String fieldName, Class<? extends U> type)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull Set<U>
    fetchSet(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull Set<U>
    fetchSet(Field<?> field, Class<? extends U> type)
    Execute the query and return all values for a field from the generated result.
    <T> @NotNull Set<T>
    fetchSet(Field<T> field)
    Execute the query and return all values for a field from the generated result.
    <T, U> @NotNull Set<U>
    fetchSet(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return all values for a field from the generated result.
    @NotNull Set<?>
    fetchSet(Name fieldName)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull Set<U>
    fetchSet(Name fieldName, Class<? extends U> type)
    Execute the query and return all values for a field name from the generated result.
    <U> @NotNull Set<U>
    fetchSet(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return all values for a field name from the generated result.
    <E> @NotNull Set<E>
    fetchSet(RecordMapper<? super R,E> mapper)
    Fetch results into a custom mapper callback.
    R
    fetchSingle()
    Execute the query and return exactly one resulting record.
    @Nullable Object
    fetchSingle(int fieldIndex)
    Execute the query and return exactly one resulting value for a field index from the generated result.
    <U> U
    fetchSingle(int fieldIndex, Class<? extends U> type)
    Execute the query and return exactly one resulting value for a field index from the generated result.
    <U> U
    fetchSingle(int fieldIndex, Converter<?,? extends U> converter)
    Execute the query and return exactly one resulting value for a field index from the generated result.
    @Nullable Object
    fetchSingle(String fieldName)
    Execute the query and return exactly one resulting value for a field name from the generated result.
    <U> U
    fetchSingle(String fieldName, Class<? extends U> type)
    Execute the query and return exactly one resulting value for a field name from the generated result.
    <U> U
    fetchSingle(String fieldName, Converter<?,? extends U> converter)
    Execute the query and return exactly one resulting value for a field name from the generated result.
    <U> U
    fetchSingle(Field<?> field, Class<? extends U> type)
    Execute the query and return exactly one resulting value for a field from the generated result.
    <T> T
    fetchSingle(Field<T> field)
    Execute the query and return exactly one resulting value for a field from the generated result.
    <T, U> U
    fetchSingle(Field<T> field, Converter<? super T,? extends U> converter)
    Execute the query and return exactly one resulting value for a field from the generated result.
    @Nullable Object
    fetchSingle(Name fieldName)
    Execute the query and return exactly one resulting value for a field name from the generated result.
    <U> U
    fetchSingle(Name fieldName, Class<? extends U> type)
    Execute the query and return exactly one resulting value for a field name from the generated result.
    <U> U
    fetchSingle(Name fieldName, Converter<?,? extends U> converter)
    Execute the query and return exactly one resulting value for a field name from the generated result.
    <E> E
    fetchSingle(RecordMapper<? super R,E> mapper)
    Execute the query and return exactly one resulting value into a custom mapper callback.
    @Nullable Object @NotNull []
    fetchSingleArray()
    Execute the query and return exactly one resulting record as an array
    <E> E
    fetchSingleInto(Class<? extends E> type)
    Map resulting records onto a custom type.
    <Z extends Record>
    Z
    fetchSingleInto(Table<Z> table)
    Map resulting records onto a custom record.
    @NotNull Map<String,Object>
    fetchSingleMap()
    Execute the query and return exactly one resulting record as a name/value map.
    @NotNull ResultQuery<R>
    fetchSize(int rows)
    Specify the fetch size of the underlying Statement.
    @NotNull Stream<R>
    fetchStream()
    Stream this query.
    <E> @NotNull Stream<E>
    fetchStreamInto(Class<? extends E> type)
    Stream this query, mapping records into a custom type.
    <Z extends Record>
    @NotNull Stream<Z>
    fetchStreamInto(Table<Z> table)
    Stream this query, mapping records into a custom record.
    @NotNull Class<? extends R>
    getRecordType()
    The record type produced by this query.
    @Nullable Result<R>
    getResult()
    Return the result generated by a previous call to execute().
    @NotNull ResultQuery<R>
    intern(int... fieldIndexes)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull ResultQuery<R>
    intern(String... fieldNames)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull ResultQuery<R>
    intern(Field<?>... fields)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull ResultQuery<R>
    intern(Name... fieldNames)
    Deprecated, for removal: This API element is subject to removal in a future version.
    - 3.10 - [#6254] - This functionality is no longer supported and will be removed in 4.0
    @NotNull Iterator<R>
    iterator()
    Execute the query using fetch() and return the generated result as an Iterator.
    @NotNull ResultQuery<R>
    keepStatement(boolean keepStatement)
    Keep the query's underlying statement open after execution.
    @NotNull ResultQuery<R>
    maxRows(int rows)
    Specify the maximum number of rows returned by the underlying Statement.
    @NotNull ResultQuery<R>
    poolable(boolean poolable)
    Specify whether any JDBC Statement created by this query should be Statement.setPoolable(boolean).
    @NotNull ResultQuery<R>
    queryTimeout(int timeout)
    Specify the query timeout in number of seconds for the underlying JDBC Statement.
    @NotNull ResultQuery<R>
    resultSetConcurrency(int resultSetConcurrency)
    Specify the ResultSet concurrency of ResultSet objects created by jOOQ.
    @NotNull ResultQuery<R>
    resultSetHoldability(int resultSetHoldability)
    Specify the ResultSet holdability of ResultSet objects created by jOOQ.
    @NotNull ResultQuery<R>
    resultSetType(int resultSetType)
    Specify the ResultSet type of ResultSet objects created by jOOQ.
    default @NotNull Spliterator<R>
    spliterator()
    Execute the query using fetch() and return the generated result as an Spliterator.
    @NotNull Stream<R>
    stream()
    Stream this query.

    Methods inherited from interface org.jooq.Attachable

    attach, configuration, detach

    Methods inherited from interface org.jooq.AttachableQueryPart

    getBindValues, getParam, getParams, getSQL, getSQL

    Methods inherited from interface org.jooq.Fields

    dataType, dataType, dataType, dataTypes, field, field, field, field, field, field, field, field, field, field, fields, fields, fields, fields, fields, fieldsRow, fieldStream, indexOf, indexOf, indexOf, type, type, type, types

    Methods inherited from interface java.lang.Iterable

    forEach

    Methods inherited from interface org.jooq.Publisher

    subscribe

    Methods inherited from interface org.reactivestreams.Publisher

    subscribe

    Methods inherited from interface org.jooq.Query

    cancel, close, execute, executeAsync, executeAsync, isExecutable

    Methods inherited from interface org.jooq.QueryPart

    $replace, $replace, $traverse, $traverse, equals, hashCode, toString