Module org.jooq
Package org.jooq

Interface Record

  • All Superinterfaces:
    Attachable, Comparable<Record>, Fields, Formattable, Serializable
    All Known Subinterfaces:
    EmbeddableRecord<R>, Record1<T1>, Record10<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>, Record11<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>, Record12<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>, Record13<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>, Record14<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>, Record15<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>, Record16<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>, Record17<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17>, Record18<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18>, Record19<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19>, Record2<T1,​T2>, Record20<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20>, Record21<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21>, Record22<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22>, Record3<T1,​T2,​T3>, Record4<T1,​T2,​T3,​T4>, Record5<T1,​T2,​T3,​T4,​T5>, Record6<T1,​T2,​T3,​T4,​T5,​T6>, Record7<T1,​T2,​T3,​T4,​T5,​T6,​T7>, Record8<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>, Record9<T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>, TableRecord<R>, UDTRecord<R>, UpdatableRecord<R>
    All Known Implementing Classes:
    CustomRecord, EmbeddableRecordImpl, TableRecordImpl, UDTRecordImpl, UpdatableRecordImpl

    public interface Record
    extends Fields, Attachable, Comparable<Record>, Formattable
    A database result record.

    A record essentially combines a list of columns (Field) with a corresponding list of values, each value being of the respective field's type.

    While records can be seen as generic column / value mappings, their concrete implementations often specialise the above description in any of the following ways:

    Table records

    Records originating from a concrete database table (or view) are modelled by jOOQ as TableRecord or UpdatableRecord, if they contain a primary key. If you're using jOOQ's code generator, you can generate even more concrete types of table records, i.e. one table record per table.

    UDT records

    SQLDialect.ORACLE and SQLDialect.POSTGRES formally support user defined types (UDT), which are modelled by jOOQ as UDTRecord. In addition to being regular records (column / value mappings), they also implement the JDBC SQLData API in order to be streamed to a JDBC PreparedStatement or from a JDBC ResultSet

    Records of well-defined degree

    When projecting custom record types in SQL, new ad-hoc types of a certain degree are formed on the fly. Records with degree <= 22 are reflected by jOOQ through the Record1, Record2, ... Record22 classes, which cover the respective row value expressions Row1, Row2, ... Row22

    Note that generated TableRecords and UDTRecords also implement a Record[N] interface, if N <= 22

    Record implements Comparable

    jOOQ records have a natural ordering implemented in the same way as this is defined in the SQL standard. For more details, see the compareTo(Record) method.

    Importing Record

    Starting from Java 14, the Record type conflicts with java.lang.Record, which is always imported by default. According to Java Language Specification, this means that jOOQ's Record type can no longer be imported on demand. This is not sufficient:

     
     import org.jooq.*;
     
     
    You have to do this instead:
     
     import org.jooq.*;
     import org.jooq.Record;
     
     
    Author:
    Lukas Eder
    See Also:
    Result
    • Method Summary

      All Methods Instance Methods Abstract Methods Deprecated Methods 
      Modifier and Type Method Description
      boolean changed()
      Check if this record has been changed from its original as fetched from the database.
      void changed​(boolean changed)
      Set all of this record's internal changed flags to the supplied value.
      boolean changed​(int fieldIndex)
      Check if a field's value has been changed from its original as fetched from the database.
      void changed​(int fieldIndex, boolean changed)
      Set this record's internal changed flag to the supplied value for a given field.
      boolean changed​(String fieldName)
      Check if a field's value has been changed from its original as fetched from the database.
      void changed​(String fieldName, boolean changed)
      Set this record's internal changed flag to the supplied value for a given field.
      boolean changed​(Field<?> field)
      Check if a field's value has been changed from its original as fetched from the database.
      void changed​(Field<?> field, boolean changed)
      Set this record's internal changed flag to the supplied value for a given field.
      boolean changed​(Name fieldName)
      Check if a field's value has been changed from its original as fetched from the database.
      void changed​(Name fieldName, boolean changed)
      Set this record's internal changed flag to the supplied value for a given field.
      int compareTo​(Record record)
      Compares this Record with another Record according to their natural ordering.
      boolean equals​(Object other)
      Compare this Record with another Record for equality.
      void from​(Object source)
      Load data into this record from a source.
      void from​(Object source, int... fieldIndexes)
      Load data into this record from a source, providing some field indexes.
      void from​(Object source, String... fieldNames)
      Load data into this record from a source, providing some field names.
      void from​(Object source, Field<?>... fields)
      Load data into this record from a source, providing some fields.
      void from​(Object source, Name... fieldNames)
      Load data into this record from a source, providing some field names.
      void fromArray​(Object... array)
      Load data from an array into this record.
      void fromArray​(Object[] array, int... fieldIndexes)
      Load data from an array into this record, providing some fields indexes.
      void fromArray​(Object[] array, String... fieldNames)
      Load data from an array into this record, providing some fields names.
      void fromArray​(Object[] array, Field<?>... fields)
      Load data from an array into this record, providing some fields.
      void fromArray​(Object[] array, Name... fieldNames)
      Load data from an array into this record, providing some fields names.
      void fromMap​(Map<String,​?> map)
      Load data from a map into this record.
      void fromMap​(Map<String,​?> map, int... fieldIndexes)
      Load data from a map into this record, providing some field indexes.
      void fromMap​(Map<String,​?> map, String... fieldNames)
      Load data from a map into this record, providing some field names.
      void fromMap​(Map<String,​?> map, Field<?>... fields)
      Load data from a map into this record, providing some fields.
      void fromMap​(Map<String,​?> map, Name... fieldNames)
      Load data from a map into this record, providing some field names.
      @Nullable Object get​(int index)
      Get a value from this record, providing a field index.
      <U> U get​(int index, Class<? extends U> type)
      Get a converted value from this record, providing a field index.
      <U> U get​(int index, Converter<?,​? extends U> converter)
      Get a converted value from this record, providing a field index.
      @Nullable Object get​(String fieldName)
      Get a value from this Record, providing a field name.
      <U> U get​(String fieldName, Class<? extends U> type)
      Get a converted value from this Record, providing a field name.
      <U> U get​(String fieldName, Converter<?,​? extends U> converter)
      Get a converted value from this Record, providing a field name.
      <U> U get​(Field<?> field, Class<? extends U> type)
      Get a converted value from this Record, providing a field.
      <T> T get​(Field<T> field)
      Get a value from this Record, providing a field.
      <T,​U>
      U
      get​(Field<T> field, Converter<? super T,​? extends U> converter)
      Get a converted value from this Record, providing a field.
      @Nullable Object get​(Name fieldName)
      Get a value from this Record, providing a field name.
      <U> U get​(Name fieldName, Class<? extends U> type)
      Get a converted value from this Record, providing a field name.
      <U> U get​(Name fieldName, Converter<?,​? extends U> converter)
      Get a converted value from this Record, providing a field name.
      Object getValue​(int index)
      Get a value from this record, providing a field index.
      <T> T getValue​(int index, Class<? extends T> type)
      Get a converted value from this record, providing a field index.
      <U> U getValue​(int index, Class<? extends U> type, U defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      Object getValue​(int index, Object defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      <U> U getValue​(int index, Converter<?,​? extends U> converter)
      Get a converted value from this record, providing a field index.
      <U> U getValue​(int index, Converter<?,​? extends U> converter, U defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      Object getValue​(String fieldName)
      Get a value from this Record, providing a field name.
      <T> T getValue​(String fieldName, Class<? extends T> type)
      Get a converted value from this Record, providing a field name.
      <U> U getValue​(String fieldName, Class<? extends U> type, U defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      Object getValue​(String fieldName, Object defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      <U> U getValue​(String fieldName, Converter<?,​? extends U> converter)
      Get a converted value from this Record, providing a field name.
      <U> U getValue​(String fieldName, Converter<?,​? extends U> converter, U defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      <T> T getValue​(Field<?> field, Class<? extends T> type)
      Get a converted value from this Record, providing a field.
      <U> U getValue​(Field<?> field, Class<? extends U> type, U defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      <T> T getValue​(Field<T> field)
      Get a value from this Record, providing a field.
      <T,​U>
      U
      getValue​(Field<T> field, Converter<? super T,​? extends U> converter)
      Get a converted value from this Record, providing a field.
      <T,​U>
      U
      getValue​(Field<T> field, Converter<? super T,​? extends U> converter, U defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      <T> T getValue​(Field<T> field, T defaultValue)
      Deprecated.
      - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
      Object getValue​(Name fieldName)
      Get a value from this Record, providing a field name.
      <T> T getValue​(Name fieldName, Class<? extends T> type)
      Get a converted value from this Record, providing a field name.
      <U> U getValue​(Name fieldName, Converter<?,​? extends U> converter)
      Get a converted value from this Record, providing a field name.
      int hashCode()
      Get a hash code of this Record, based on the underlying row value expression.
      <E> E into​(E object)
      Map resulting records onto a custom type.
      <E> E into​(Class<? extends E> type)
      Map resulting records onto a custom type.
      @NotNull Record into​(Field<?>... fields)
      Copy this record into a new record holding only a subset of the previous fields.
      <T1> @NotNull Record1<T1> into​(Field<T1> field1)
      Copy this record into a new record holding only a subset of the previous fields.
      <T1,​T2>
      @NotNull Record2<T1,​T2>
      into​(Field<T1> field1, Field<T2> field2)
      Copy this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3>
      @NotNull Record3<T1,​T2,​T3>
      into​(Field<T1> field1, Field<T2> field2, Field<T3> field3)
      Copy this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4>
      @NotNull Record4<T1,​T2,​T3,​T4>
      into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4)
      Copy this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5>
      @NotNull Record5<T1,​T2,​T3,​T4,​T5>
      into​(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5)
      Copy this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22>
      @NotNull 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 this record into a new record holding only a subset of the previous fields.
      <R extends Record>
      R
      into​(Table<R> table)
      Map resulting records onto a custom record type.
      @NotNull Object[] intoArray()
      Convert this record into an array.
      @NotNull List<Object> intoList()
      Convert this record into a list.
      @NotNull Map<String,​Object> intoMap()
      Return this record as a name/value map.
      @NotNull ResultSet intoResultSet()
      Generate an in-memory JDBC ResultSet containing the data of this Record.
      @NotNull Stream<Object> intoStream()
      Convert this record into a stream.
      <E> E map​(RecordMapper<Record,​E> mapper)
      Map this record into a custom mapper callback.
      @NotNull Record original()
      Get this record containing the original values as fetched from the database.
      @Nullable Object original​(int fieldIndex)
      Get an original value from this record as fetched from the database.
      @Nullable Object original​(String fieldName)
      Get an original value from this record as fetched from the database.
      <T> T original​(Field<T> field)
      Get an original value from this record as fetched from the database.
      @Nullable Object original​(Name fieldName)
      Get an original value from this record as fetched from the database.
      void reset()
      Reset all values to their original() values and all changed() flags to false.
      void reset​(int fieldIndex)
      Reset a given value to its original(int) value and its changed(int) flag to false.
      void reset​(String fieldName)
      Reset a given value to its original(String) value and its changed(String) flag to false.
      void reset​(Field<?> field)
      Reset a given value to its original(Field) value and its changed(Field) flag to false.
      void reset​(Name fieldName)
      Reset a given value to its original(Name) value and its changed(Name) flag to false.
      <T> void set​(Field<T> field, T value)
      Set a value into this record.
      <T,​U>
      void
      set​(Field<T> field, U value, Converter<? extends T,​? super U> converter)
      Set a value into this record.
      <T> void setValue​(Field<T> field, T value)
      Set a value into this record.
      <T,​U>
      void
      setValue​(Field<T> field, U value, Converter<? extends T,​? super U> converter)
      Set a value into this record.
      int size()
      Get the number of fields of this record.
      @NotNull Row valuesRow()
      Get this record's values as a Row.
      <T> @NotNull Record with​(Field<T> field, T value)
      Set a value into this record.
      <T,​U>
      @NotNull Record
      with​(Field<T> field, U value, Converter<? extends T,​? super U> converter)
      Set a value into this record.
    • Method Detail

      • valuesRow

        @NotNull
        @NotNull Row valuesRow()
        Get this record's values as a Row.
      • get

        <T> T get​(Field<T> field)
           throws IllegalArgumentException
        Get a value from this Record, providing a field.

        If this record contains a field with the same Field.getName() as the argument field, that value is retrieved.

        Type Parameters:
        T - The generic field parameter
        Parameters:
        field - The field
        Returns:
        The value of a field contained in this record
        Throws:
        IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
      • get

        <T,​U> U get​(Field<T> field,
                          Converter<? super T,​? extends U> converter)
                   throws IllegalArgumentException,
                          DataTypeException
        Get a converted value from this Record, providing a field.

        If this record contains a field with the same Field.getName() as the argument field, that value is retrieved.

        Type Parameters:
        T - The database type parameter
        U - The conversion type parameter
        Parameters:
        field - The field
        converter - The data type converter
        Returns:
        The value of a field contained in this record
        Throws:
        IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
      • get

        @Nullable
        @Nullable Object get​(String fieldName)
                      throws IllegalArgumentException
        Get a value from this Record, providing a field name.
        Parameters:
        fieldName - The field's name
        Returns:
        The value of a field's name contained in this record
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
      • get

        <U> U get​(String fieldName,
                  Converter<?,​? extends U> converter)
           throws IllegalArgumentException,
                  DataTypeException
        Get a converted value from this Record, providing a field name.
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        fieldName - The field's name
        converter - The data type converter
        Returns:
        The value of a field's name contained in this record
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
        DataTypeException - wrapping any data type conversion exception that might have occurred
      • get

        @Nullable
        @Nullable Object get​(Name fieldName)
                      throws IllegalArgumentException
        Get a value from this Record, providing a field name.
        Parameters:
        fieldName - The field's name
        Returns:
        The value of a field's name contained in this record
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
      • get

        <U> U get​(Name fieldName,
                  Converter<?,​? extends U> converter)
           throws IllegalArgumentException,
                  DataTypeException
        Get a converted value from this Record, providing a field name.
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        fieldName - The field's name
        converter - The data type converter
        Returns:
        The value of a field's name contained in this record
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
        DataTypeException - wrapping any data type conversion exception that might have occurred
      • get

        @Nullable
        @Nullable Object get​(int index)
                      throws IllegalArgumentException
        Get a value from this record, providing a field index.
        Parameters:
        index - The 0-based field index in this record.
        Returns:
        The value of a field's index contained in this record
        Throws:
        IllegalArgumentException - If the argument index is not contained in the record
      • get

        <U> U get​(int index,
                  Class<? extends U> type)
           throws IllegalArgumentException,
                  DataTypeException
        Get a converted value from this record, providing a field index.

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

        Type Parameters:
        U - The conversion type parameter
        Parameters:
        index - The 0-based field index in this record.
        type - The conversion type
        Returns:
        The value of a field's index contained in this record
        Throws:
        IllegalArgumentException - If the argument index is not contained in the record
        DataTypeException - wrapping data type conversion exception that might have occurred
      • get

        <U> U get​(int index,
                  Converter<?,​? extends U> converter)
           throws IllegalArgumentException,
                  DataTypeException
        Get a converted value from this record, providing a field index.
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        index - The 0-based field index in this record.
        converter - The data type converter
        Returns:
        The value of a field's index contained in this record
        Throws:
        IllegalArgumentException - If the argument index is not contained in the record
        DataTypeException - wrapping data type conversion exception that might have occurred
      • set

        <T> void set​(Field<T> field,
                     T value)
        Set a value into this record.

        This will always set the changed(Field) flag for the given field, no matter if setting the value actually changes the value.

        Changing Table.getPrimaryKey() values will set all changed() flags to true, in order to produce complete INSERT statements on subsequent UpdatableRecord.store() operations.

        Type Parameters:
        T - The generic field parameter
        Parameters:
        field - The field
        value - The value
      • set

        <T,​U> void set​(Field<T> field,
                             U value,
                             Converter<? extends T,​? super U> converter)
        Set a value into this record.

        This will always set the changed(Field) flag for the given field, no matter if setting the value actually changes the value.

        Changing Table.getPrimaryKey() values will set all changed() flags to true, in order to produce complete INSERT statements on subsequent UpdatableRecord.store() operations.

        Type Parameters:
        T - The generic field parameter
        U - The conversion type parameter
        Parameters:
        field - The field
        value - The value
        converter - The converter used to convert value into an appropriate type
      • with

        @NotNull
        <T> @NotNull Record with​(Field<T> field,
                                 T value)
        Set a value into this record.

        Like set(Field, Object) but returning this for fluent setting of multiple values.

      • with

        @NotNull
        <T,​U> @NotNull Record with​(Field<T> field,
                                         U value,
                                         Converter<? extends T,​? super U> converter)
        Set a value into this record.

        Like set(Field, Object, Converter) but returning this for fluent setting of multiple values.

      • size

        int size()
        Get the number of fields of this record.
      • original

        @NotNull
        @NotNull Record original()
        Get this record containing the original values as fetched from the database.

        Record values can be freely modified after having fetched a record from the database. Every record also references the originally fetched values. This method returns a new record containing those original values.

        See Also:
        original(Field), original(int), original(String)
      • original

        <T> T original​(Field<T> field)
        Get an original value from this record as fetched from the database.

        Record values can be freely modified after having fetched a record from the database. Every record also references the originally fetched values. This method returns such an original value for a field.

        See Also:
        original()
      • original

        @Nullable
        @Nullable Object original​(int fieldIndex)
        Get an original value from this record as fetched from the database.

        Record values can be freely modified after having fetched a record from the database. Every record also references the originally fetched values. This method returns such an original value for a field.

        Parameters:
        fieldIndex - The 0-based field index in this record.
        See Also:
        original()
      • original

        @Nullable
        @Nullable Object original​(String fieldName)
        Get an original value from this record as fetched from the database.

        Record values can be freely modified after having fetched a record from the database. Every record also references the originally fetched values. This method returns such an original value for a field.

        See Also:
        original()
      • original

        @Nullable
        @Nullable Object original​(Name fieldName)
        Get an original value from this record as fetched from the database.

        Record values can be freely modified after having fetched a record from the database. Every record also references the originally fetched values. This method returns such an original value for a field.

        See Also:
        original()
      • changed

        boolean changed()
        Check if this record has been changed from its original as fetched from the database.

        If this returns false, then it can be said that record.equals(record.original()) is true.

        See Also:
        original(), changed(Field), changed(int), changed(String)
      • changed

        boolean changed​(Field<?> field)
        Check if a field's value has been changed from its original as fetched from the database.
        See Also:
        changed(), original(Field)
      • changed

        boolean changed​(int fieldIndex)
        Check if a field's value has been changed from its original as fetched from the database.
        Parameters:
        fieldIndex - The 0-based field index in this record.
        See Also:
        changed(), original(int)
      • changed

        boolean changed​(String fieldName)
        Check if a field's value has been changed from its original as fetched from the database.
        See Also:
        changed(), original(String)
      • changed

        boolean changed​(Name fieldName)
        Check if a field's value has been changed from its original as fetched from the database.
        See Also:
        changed(), original(Name)
      • changed

        void changed​(Field<?> field,
                     boolean changed)
        Set this record's internal changed flag to the supplied value for a given field.

        If the changed argument is false, the original(Field) value will be reset to the corresponding "current" value as well

        See Also:
        changed(), changed(Field)
      • changed

        void changed​(int fieldIndex,
                     boolean changed)
        Set this record's internal changed flag to the supplied value for a given field.

        If the changed argument is false, the original(int) value will be reset to the corresponding "current" value as well

        Parameters:
        fieldIndex - The 0-based field index in this record.
        See Also:
        changed(), changed(int)
      • changed

        void changed​(String fieldName,
                     boolean changed)
        Set this record's internal changed flag to the supplied value for a given field.

        If the changed argument is false, the original(String) value will be reset to the corresponding "current" value as well

        See Also:
        changed(), changed(String)
      • changed

        void changed​(Name fieldName,
                     boolean changed)
        Set this record's internal changed flag to the supplied value for a given field.

        If the changed argument is false, the original(Name) value will be reset to the corresponding "current" value as well

        See Also:
        changed(), changed(Name)
      • reset

        void reset()
        Reset all values to their original() values and all changed() flags to false.
      • reset

        void reset​(int fieldIndex)
        Reset a given value to its original(int) value and its changed(int) flag to false.
        Parameters:
        fieldIndex - The 0-based field index in this record.
      • intoArray

        @NotNull
        @NotNull Object[] intoArray()
        Convert this record into an array.

        The resulting array has the same number of elements as this record has fields. The resulting array contains data as such:

         // For arbitrary values of i
         record.getValue(i) == record.intoArray()[i]
         

        This is the same as calling into(Object[].class)

        Returns:
        This record as an array
        See Also:
        fromArray(Object...)
      • intoList

        @NotNull
        @NotNull List<Object> intoList()
        Convert this record into a list.

        The resulting list has the same number of elements as this record has fields. The resulting array contains data as such:

         // For arbitrary values of i
         record.getValue(i) == record.intoList().get(i)
         

        This is the same as calling Arrays.asList(intoArray())

      • intoStream

        @NotNull
        @NotNull Stream<Object> intoStream()
        Convert this record into a stream.

        The resulting stream has the same number of elements as this record has fields. The resulting stream contains data as such:

        This is the same as calling into(Stream.class)

        Returns:
        This record as a stream
      • intoMap

        @NotNull
        @NotNull Map<String,​Object> intoMap()
        Return this record as a name/value map.

        This is the inverse operation to fromMap(Map)

        Returns:
        This record as a map
        See Also:
        fromMap(Map)
      • into

        @NotNull
        @NotNull Record into​(Field<?>... fields)
        Copy this record into a new record holding only a subset of the previous fields.
        Parameters:
        fields - The fields of the new record
        Returns:
        The new record
      • into

        @NotNull
        <T1> @NotNull Record1<T1> into​(Field<T1> field1)
        Copy this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2> @NotNull Record2<T1,​T2> into​(Field<T1> field1,
                                                         Field<T2> field2)
        Copy this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3> @NotNull Record3<T1,​T2,​T3> into​(Field<T1> field1,
                                                                           Field<T2> field2,
                                                                           Field<T3> field3)
        Copy this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4> @NotNull Record4<T1,​T2,​T3,​T4> into​(Field<T1> field1,
                                                                                             Field<T2> field2,
                                                                                             Field<T3> field3,
                                                                                             Field<T4> field4)
        Copy this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5> @NotNull Record5<T1,​T2,​T3,​T4,​T5> into​(Field<T1> field1,
                                                                                                               Field<T2> field2,
                                                                                                               Field<T3> field3,
                                                                                                               Field<T4> field4,
                                                                                                               Field<T5> field5)
        Copy this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19,​T20,​T21,​T22> @NotNull 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 this record into a new record holding only a subset of the previous fields.
        Returns:
        The new record
        See Also:
        into(Table)
      • into

        @NotNull
        <E> E into​(E object)
            throws MappingException
        Map resulting records onto a custom type.

        This is the same as into(Class), except that no new object is instantiated as a result. Instead, you can provide your own custom POJO instance.

        Type Parameters:
        E - The generic entity type.
        Parameters:
        object - The receiving bean.
        Throws:
        MappingException - wrapping any reflection exception that might have occurred while mapping records
        NullPointerException - if object is null
        See Also:
        from(Object)
      • into

        @NotNull
        <R extends Record> R into​(Table<R> table)
        Map resulting records onto a custom record type.

        The mapping algorithm is this:

        jOOQ will map Record values by equal field names:

        • For every field in the table argument with Field.getName() "MY_field" (case-sensitive!), a corresponding field with the same name in this record will be searched.
        • If several fields in this record share the same Field.getName(), then the first one returning true on Field.equals(Object) will be returned. (e.g. qualified field names match)

        Other restrictions

        Type Parameters:
        R - The generic table record type.
        Parameters:
        table - The table type.
      • map

        @NotNull
        <E> E map​(RecordMapper<Record,​E> mapper)
        Map this record into a custom mapper callback.
        Parameters:
        mapper - The mapper callback
        Returns:
        The custom mapped record
      • from

        void from​(Object source)
           throws MappingException
        Load data into this record from a source.

        The mapping algorithm is this:

        If source is an array

        Loading of data is delegated to fromArray(Object...)

        If source is a Map

        Loading of data is delegated to fromMap(Map)

        If source is an Iterable

        Loading of data is equivalent to loading fromArray(Object...), transforming the Iterable to an array, first.

        If any JPA Column annotations are found on the Class of the provided source, only those are used. Matching candidates are:

        • Public no-argument instance methods annotated with Column
        • Public no-argument instance methods starting with getXXX or isXXX, if there exists a matching public single-argument setXXX() instance method that is annotated with Column
        • Public instance member fields annotated with Column
        Additional matching rules:
        • Column.name() must match Field.getName(). All other annotation attributes are ignored
        • Only the first match per field is used
        • Matching methods have a higher priority than matching member fields
        • Explicitly matching methods have a higher priority than implicitly matching methods (implicitly matching getter = setter is annotated)
        • Static methods / member fields are ignored

        If there are no JPA Column annotations, or jOOQ can't find the javax.persistence API on the classpath, jOOQ will map members by naming convention:

        If Field.getName() is MY_field (case-sensitive!), then this field's value will be fetched from the first of these:

        • Public no-argument instance method MY_field()
        • Public no-argument instance method myField()
        • Public no-argument instance method getMY_field()
        • Public no-argument instance method getMyField()
        • Public instance member field MY_field
        • Public instance member field myField

        Other restrictions

        • primitive types are supported.

        General notes

        The resulting record will have its internal "changed" flags set to true for all values. This means that UpdatableRecord.store() will perform an INSERT statement. If you wish to store the record using an UPDATE statement, use DSLContext.executeUpdate(UpdatableRecord) instead.

        This is the same as calling record.from(source, record.fields())

        Parameters:
        source - The source object to copy data from
        Throws:
        MappingException - wrapping any reflection exception that might have occurred while mapping records
        See Also:
        into(Class), from(Object, Field...)
      • from

        void from​(Object source,
                  Field<?>... fields)
           throws MappingException
        Load data into this record from a source, providing some fields.

        This is the same as from(Object), except that only fields contained in the fields argument will be mapped.

        Parameters:
        source - The source object to copy data from
        fields - The record's fields to use for mapping
        Throws:
        MappingException - wrapping any reflection exception that might have occurred while mapping records
        See Also:
        into(Class), from(Object)
      • from

        void from​(Object source,
                  String... fieldNames)
           throws MappingException
        Load data into this record from a source, providing some field names.

        This is the same as from(Object), except that only fields contained in the fieldNames argument will be mapped.

        Parameters:
        source - The source object to copy data from
        fieldNames - The record's fields names to use for mapping
        Throws:
        MappingException - wrapping any reflection exception that might have occurred while mapping records
        See Also:
        into(Class), from(Object)
      • from

        void from​(Object source,
                  Name... fieldNames)
           throws MappingException
        Load data into this record from a source, providing some field names.

        This is the same as from(Object), except that only fields contained in the fieldNames argument will be mapped.

        Parameters:
        source - The source object to copy data from
        fieldNames - The record's fields names to use for mapping
        Throws:
        MappingException - wrapping any reflection exception that might have occurred while mapping records
        See Also:
        into(Class), from(Object)
      • from

        void from​(Object source,
                  int... fieldIndexes)
           throws MappingException
        Load data into this record from a source, providing some field indexes.

        This is the same as from(Object), except that only fields contained in the fieldIndexes argument will be mapped.

        Parameters:
        source - The source object to copy data from
        fieldIndexes - The record's 0-based field indexes to use for mapping
        Throws:
        MappingException - wrapping any reflection exception that might have occurred while mapping records
        See Also:
        into(Class), from(Object)
      • fromMap

        void fromMap​(Map<String,​?> map)
        Load data from a map into this record.

        The argument map is expected to hold field-name / value pairs where field-names correspond to actual field names as provided by Fields.field(String). Missing fields will be left untouched. Excess fields will be ignored.

        This is the inverse operation to intoMap(). This is the same as calling record.fromMap(map, record.fields())

        See Also:
        intoMap(), fromMap(Map, Field...)
      • fromMap

        void fromMap​(Map<String,​?> map,
                     Field<?>... fields)
        Load data from a map into this record, providing some fields.

        The argument map is expected to hold field-name / value pairs where field-names correspond to actual field names as provided by Fields.field(String). Missing fields will be left untouched. Excess fields will be ignored.

        This is the same as fromMap(Map), except that only fields contained in the fields argument will be mapped.

        See Also:
        intoMap(), fromMap(Map)
      • fromMap

        void fromMap​(Map<String,​?> map,
                     String... fieldNames)
        Load data from a map into this record, providing some field names.

        The argument map is expected to hold field-name / value pairs where field-names correspond to actual field names as provided by Fields.field(String). Missing fields will be left untouched. Excess fields will be ignored.

        This is the same as fromMap(Map), except that only fields contained in the fieldNames argument will be mapped.

        See Also:
        intoMap(), fromMap(Map)
      • fromMap

        void fromMap​(Map<String,​?> map,
                     Name... fieldNames)
        Load data from a map into this record, providing some field names.

        The argument map is expected to hold field-name / value pairs where field-names correspond to actual field names as provided by Fields.field(Name). Missing fields will be left untouched. Excess fields will be ignored.

        This is the same as fromMap(Map), except that only fields contained in the fieldNames argument will be mapped.

        See Also:
        intoMap(), fromMap(Map)
      • fromMap

        void fromMap​(Map<String,​?> map,
                     int... fieldIndexes)
        Load data from a map into this record, providing some field indexes.

        The argument map is expected to hold field-name / value pairs where field-names correspond to actual field names as provided by Fields.field(String). Missing fields will be left untouched. Excess fields will be ignored.

        This is the same as fromMap(Map), except that only fields contained in the fieldIndexes argument will be mapped.

        Parameters:
        fieldIndexes - The 0-based field indexes in this record.
        See Also:
        intoMap(), fromMap(Map)
      • fromArray

        void fromArray​(Object... array)
        Load data from an array into this record.

        The argument array is expected to hold values for this record's field indexes. Missing values will be left untouched. Excess values will be ignored.

        This is the inverse operation to intoArray()

        See Also:
        intoArray(), fromArray(Object[], Field...)
      • fromArray

        void fromArray​(Object[] array,
                       Field<?>... fields)
        Load data from an array into this record, providing some fields.

        The argument array is expected to hold values for this record's field indexes. Missing values will be left untouched. Excess values will be ignored.

        This is the same as fromArray(Object...), except that only fields contained in the fields argument will be mapped.

        See Also:
        intoArray(), fromArray(Object...)
      • fromArray

        void fromArray​(Object[] array,
                       String... fieldNames)
        Load data from an array into this record, providing some fields names.

        The argument array is expected to hold values for this record's field indexes. Missing values will be left untouched. Excess values will be ignored.

        This is the same as fromArray(Object...), except that only fields contained in the fieldNames argument will be mapped.

        See Also:
        intoArray(), fromArray(Object...)
      • fromArray

        void fromArray​(Object[] array,
                       Name... fieldNames)
        Load data from an array into this record, providing some fields names.

        The argument array is expected to hold values for this record's field indexes. Missing values will be left untouched. Excess values will be ignored.

        This is the same as fromArray(Object...), except that only fields contained in the fieldNames argument will be mapped.

        See Also:
        intoArray(), fromArray(Object...)
      • fromArray

        void fromArray​(Object[] array,
                       int... fieldIndexes)
        Load data from an array into this record, providing some fields indexes.

        The argument array is expected to hold values for this record's field indexes. Missing values will be left untouched. Excess values will be ignored.

        This is the same as fromArray(Object...), except that only fields contained in the fieldIndexes argument will be mapped.

        Parameters:
        fieldIndexes - The 0-based field indexes in this record.
        See Also:
        intoArray(), fromArray(Object...)
      • hashCode

        int hashCode()
        Get a hash code of this Record, based on the underlying row value expression.

        In order to fulfill the general contract of Object.hashCode() and Object.equals(Object), a Record's hash code value depends on all hash code values of this Record's underlying column values.

        Overrides:
        hashCode in class Object
        Returns:
        A hash code value for this record
        See Also:
        equals(Object)
      • equals

        boolean equals​(Object other)
        Compare this Record with another Record for equality.

        Two records are considered equal if

        • They have the same degree
        • For every i BETWEEN 0 AND degree, r1[i] = r2[i]

        Note, that the above rules correspond to the SQL comparison predicate behaviour as illustrated in the following example:

         -- A row value expression comparison predicate
         SELECT *
         FROM my_table
         WHERE (1, 'A') = (1, 'A')
         

        Unlike SQL, jOOQ allows to compare also incompatible records, e.g. records

        • ... whose degrees are not equal (results in false)
        • ... whose column types are not equal (results in false)
        • ... whose record types are not equal (irrelevant for the result)

        It can be said that for all R1, R2, if R1.equal(R2), then R1.compareTo(R2) == 0

        Overrides:
        equals in class Object
        Parameters:
        other - The other record
        Returns:
        Whether the two records are equal
        See Also:
        compareTo(Record), hashCode()
      • compareTo

        int compareTo​(Record record)
        Compares this Record with another Record according to their natural ordering.

        jOOQ Records implement Comparable to allow for naturally ordering Records in a "SQL way", i.e. according to the following rules:

        Records being compared must have the same ROW type

        Two Records are comparable if and only if they have the same ROW type, i.e. if their fieldsRow() methods return fields of the same type and degree.

        Comparison rules

        Assume the following notations:

        • X[i] means X.getValue(i)
        • X = Y means X.compareTo(Y) == 0
        • X < Y means X.compareTo(Y) < 0
        • X[i] = Y[i] means (X[i] == null && Y[i] == null) || X[i].compareTo(Y[i]) == 0
        • X[i] < Y[i] means Y[i] == null || X[i].compareTo(Y[i]) < 0. This corresponds to the SQL NULLS LAST clause.
        Then, for two comparable Records r1 and r2, x = r1.compareTo(r2) yields:
        • x = -1: if
              (r1[0] < r2[0])
           OR (r1[0] = r2[0] AND r1[1] < r2[1])
           OR  ...
           OR (r1[0] = r2[0] AND ... AND r1[N-1] = r2[N-1] AND r1[N] < r2[N])
        • x = 0: if
           OR (r1[0] = r2[0] AND ... AND r1[N-1] = r2[N-1] AND r1[N] = r2[N])
        • x = 1: if
              (r1[0] > r2[0])
           OR (r1[0] = r2[0] AND r1[1] > r2[1])
           OR  ...
           OR (r1[0] = r2[0] AND ... AND r1[N-1] = r2[N-1] AND r1[N] > r2[N])

        Note, that the above rules correspond to the SQL ordering behaviour as illustrated in the following examples:

         -- A SQL ORDER BY clause, ordering all records by columns in their order
         SELECT a, b, c
         FROM my_table
         ORDER BY 1, 2, 3
        
         -- A row value expression comparison predicate
         SELECT *
         FROM my_table
         WHERE (a, b, c) < (1, 2, 3)
         

        See Row1.lessThan(Row1), Row2.lessThan(Row2), ..., Row22.lessThan(Row22) for more details about row value expression comparison predicates

        Alternative sorting behaviour can be achieved through Result.sortAsc(java.util.Comparator) and similar methods.

        Specified by:
        compareTo in interface Comparable<Record>
        Throws:
        NullPointerException - If the argument record is null
        ClassCastException - If the argument record is not comparable with this record according to the above rules.
      • getValue

        @Deprecated
        <T> T getValue​(Field<T> field,
                       T defaultValue)
                throws IllegalArgumentException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a value from this record, providing a field.
        Type Parameters:
        T - The generic field parameter
        Parameters:
        field - The field
        defaultValue - The default value instead of null
        Returns:
        The value of a field contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
      • getValue

        @Deprecated
        <T,​U> U getValue​(Field<T> field,
                               Converter<? super T,​? extends U> converter,
                               U defaultValue)
                        throws IllegalArgumentException,
                               DataTypeException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a converted value from this record, providing a field.
        Type Parameters:
        T - The database type parameter
        U - The conversion type parameter
        Parameters:
        field - The field
        converter - The data type converter
        defaultValue - The default value instead of null
        Returns:
        The value of a field contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument field is not contained in Fields.fieldsRow()
        DataTypeException - wrapping any data type conversion exception that might have occurred
      • getValue

        @Deprecated
        Object getValue​(String fieldName,
                        Object defaultValue)
                 throws IllegalArgumentException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a value from this record, providing a field name.
        Parameters:
        fieldName - The field's name
        defaultValue - The default value instead of null
        Returns:
        The value of a field's name contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
      • getValue

        @Deprecated
        <U> U getValue​(String fieldName,
                       Class<? extends U> type,
                       U defaultValue)
                throws IllegalArgumentException,
                       DataTypeException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a converted value from this record, providing a field name.

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

        Type Parameters:
        U - The conversion type parameter
        Parameters:
        fieldName - The field's name
        type - The conversion type
        defaultValue - The default value instead of null
        Returns:
        The value of a field's name contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
        DataTypeException - wrapping any data type conversion exception that might have occurred
      • getValue

        @Deprecated
        <U> U getValue​(String fieldName,
                       Converter<?,​? extends U> converter,
                       U defaultValue)
                throws IllegalArgumentException,
                       DataTypeException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a converted value from this record, providing a field name.
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        fieldName - The field's name
        converter - The data type converter
        defaultValue - The default value instead of null
        Returns:
        The value of a field's name contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument fieldName is not contained in the record
        DataTypeException - wrapping any data type conversion exception that might have occurred
      • getValue

        @Deprecated
        Object getValue​(int index,
                        Object defaultValue)
                 throws IllegalArgumentException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a value from this record, providing a field index.
        Parameters:
        index - The 0-based field index in this record.
        defaultValue - The default value instead of null
        Returns:
        The value of a field's index contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument index is not contained in the record
      • getValue

        @Deprecated
        <U> U getValue​(int index,
                       Class<? extends U> type,
                       U defaultValue)
                throws IllegalArgumentException,
                       DataTypeException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a converted value from this record, providing a field index.

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

        Type Parameters:
        U - The conversion type parameter
        Parameters:
        index - The 0-based field index in this record.
        type - The conversion type
        defaultValue - The default value instead of null
        Returns:
        The value of a field's index contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument index is not contained in the record
        DataTypeException - wrapping data type conversion exception that might have occurred
      • getValue

        @Deprecated
        <U> U getValue​(int index,
                       Converter<?,​? extends U> converter,
                       U defaultValue)
                throws IllegalArgumentException,
                       DataTypeException
        Deprecated.
        - 3.3.0 - [#2878] - This method will be removed in jOOQ 4.0
        Get a converted value from this record, providing a field index.
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        index - The 0-based field index in this record.
        converter - The data type converter
        defaultValue - The default value instead of null
        Returns:
        The value of a field's index contained in this record, or defaultValue, if null
        Throws:
        IllegalArgumentException - If the argument index is not contained in the record
        DataTypeException - wrapping data type conversion exception that might have occurred
      • setValue

        <T> void setValue​(Field<T> field,
                          T value)
        Set a value into this record.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use set(Field, Object) instead.

        See Also:
        set(Field, Object)