Module org.jooq
Package org.jooq.impl

Class UpdatableRecordImpl<R extends UpdatableRecord<R>>

    • Constructor Detail

      • UpdatableRecordImpl

        public UpdatableRecordImpl​(Table<R> table)
    • Method Detail

      • store

        public final int store()
        Description copied from interface: UpdatableRecord
        Store this record back to the database.

        Depending on the state of the primary key's value, an UpdatableRecord.insert() or an UpdatableRecord.update() statement is executed.

        Statement type

        • If this record was created by client code, an INSERT statement is executed
        • If this record was loaded by jOOQ and the primary key value was changed, an INSERT statement is executed (unless Settings.isUpdatablePrimaryKeys() is set). jOOQ expects that primary key values will never change due to the principle of normalisation in RDBMS. So if client code changes primary key values, this is interpreted by jOOQ as client code wanting to duplicate this record.
        • If this record was loaded by jOOQ, and the primary key value was not changed, an UPDATE statement is executed.

        In either statement type, only those fields are inserted/updated, which had been explicitly set by client code, in order to allow for DEFAULT values to be applied by the underlying RDBMS. If no fields were modified, neither an UPDATE nor an INSERT will be executed.

        Automatic value generation

        Use UpdatableRecord.insert() or UpdatableRecord.update() to explicitly force either statement type.

        • IDENTITY columns

          If there is an IDENTITY column defined on the record's underlying table (see Table.getIdentity()), then the auto-generated IDENTITY value is refreshed automatically on INSERT's. Refreshing is done using Statement.getGeneratedKeys(), where this is supported by the JDBC driver. See also InsertQuery.getReturnedRecord() for more details

        • VERSION and TIMESTAMP columns

          jOOQ can auto-generate "version" and "timestamp" values that can be used for optimistic locking. If this is an UpdatableRecord and if this record returns fields for either Table.getRecordVersion() or Table.getRecordTimestamp(), then these values are set onto the INSERT or UPDATE statement being executed. On execution success, the generated values are set to this record. Use the code-generation configuration to specify naming patterns for auto-generated "version" and "timestamp" columns.

          Should you want to circumvent jOOQ-generated updates to these columns, you can render an INSERT or UPDATE statement manually using the various DSLContext.insertInto(Table), DSLContext.update(Table) methods.

        Optimistic locking

        If an UPDATE statement is executed and Settings.isExecuteWithOptimisticLocking() is set to true, then this record will first be compared with the latest state in the database. There are two modes of operation for optimistic locking:

        • With VERSION and/or TIMESTAMP columns configured

          This is the preferred way of using optimistic locking in jOOQ. If this is an UpdatableRecord and if this record returns fields for either Table.getRecordVersion() or Table.getRecordTimestamp(), then these values are compared to the corresponding value in the database in the WHERE clause of the executed DELETE statement.

        • Without any specific column configurations

          In order to compare this record with the latest state, the database record will be locked pessimistically using a SELECT .. FOR UPDATE statement. Not all databases support the FOR UPDATE clause natively. Namely, the following databases will show slightly different behaviour:

          See SelectQuery.setForUpdate(boolean) for more details

        Statement examples

        Possible statements are

        •  INSERT INTO [table] ([modified fields, including keys])
           VALUES ([modified values, including keys])
        •  UPDATE [table]
           SET [modified fields = modified values, excluding keys]
           WHERE [key fields = key values]
           AND [version/timestamp fields = version/timestamp values]

        Statement execution enforcement

        If you want to enforce statement execution, regardless if the values in this record were changed, you can explicitly set the changed flags for all values with Record.changed(boolean) or for single values with Record.changed(Field, boolean), prior to storing.

        This is the same as calling record.store(record.fields())

        Specified by:
        store in interface UpdatableRecord<R extends UpdatableRecord<R>>
        Returns:
        1 if the record was stored to the database. 0 if storing was not necessary.
        See Also:
        UpdatableRecord.insert(), UpdatableRecord.update()
      • update

        public final int update()
        Description copied from interface: UpdatableRecord
        Store this record back to the database using an UPDATE statement.

        This is the same as UpdatableRecord.store(), except that an UPDATE statement (or no statement) will always be executed.

        If you want to enforce statement execution, regardless if the values in this record were changed, you can explicitly set the changed flags for all values with Record.changed(boolean) or for single values with Record.changed(Field, boolean), prior to updating.

        This is the same as calling record.update(record.fields())

        Specified by:
        update in interface UpdatableRecord<R extends UpdatableRecord<R>>
        Returns:
        1 if the record was stored to the database. 0 if storing was not necessary.
        See Also:
        UpdatableRecord.store()
      • delete

        public final int delete()
        Description copied from interface: UpdatableRecord
        Deletes this record from the database, based on the value of the primary key or main unique key.

        Optimistic locking

        If a DELETE statement is executed and Settings.isExecuteWithOptimisticLocking() is set to true, then this record will first be compared with the latest state in the database. There are two modes of operation for optimistic locking:

        • With VERSION and/or TIMESTAMP columns configured

          This is the preferred way of using optimistic locking in jOOQ. If this is an UpdatableRecord and if this record returns fields for either Table.getRecordVersion() or Table.getRecordTimestamp(), then these values are compared to the corresponding value in the database in the WHERE clause of the executed DELETE statement.

        • Without any specific column configurations

          In order to compare this record with the latest state, the database record will be locked pessimistically using a SELECT .. FOR UPDATE statement. Not all databases support the FOR UPDATE clause natively. Namely, the following databases will show slightly different behaviour:

          See SelectQuery.setForUpdate(boolean) for more details

        Statement examples

        The executed statement is

         DELETE FROM [table]
         WHERE [key fields = key values]
         AND [version/timestamp fields = version/timestamp values]

        This is in fact the same as calling delete(getTable().getPrimaryKey().getFieldsArray())

        Specified by:
        delete in interface UpdatableRecord<R extends UpdatableRecord<R>>
        Returns:
        1 if the record was deleted from the database. 0 if deletion was not necessary.
      • refresh

        public final void refresh​(Field<?>... refreshFields)
        Description copied from interface: UpdatableRecord
        Refresh parts of this record from the database.

        A successful refresh results in the following:

        Refreshing can trigger any of the following actions:

        • Executing a new SELECT statement, if this is an UpdatableRecord.
        • Failing, otherwise

        This is the same as calling record.refresh(record.fields())

        Specified by:
        refresh in interface UpdatableRecord<R extends UpdatableRecord<R>>
      • copy

        public final R copy()
        Description copied from interface: UpdatableRecord
        Duplicate this record (in memory) and reset all fields from the primary key or main unique key, such that a subsequent call to UpdatableRecord.store() will result in an INSERT statement.
        Specified by:
        copy in interface UpdatableRecord<R extends UpdatableRecord<R>>
        Returns:
        A new record, distinct from this record.
      • field

        public final <T> Field<T> field​(Field<T> field)
        Description copied from interface: Record
        Get a specific field from this Record.

        This will return:

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

        public final Field<?> field​(Name name)
        Description copied from interface: Record
        Get a specific qualified field from this Record.
        Specified by:
        field in interface Record
        See Also:
        Row.field(Name)
      • field

        public final Field<?> field​(int index)
        Description copied from interface: Record
        Get a specific field from this Record.
        Specified by:
        field in interface Record
        See Also:
        Row.field(int)
      • fields

        public final Field<?>[] fields()
        Description copied from interface: Record
        Get all fields from this Record.
        Specified by:
        fields in interface Record
        See Also:
        Row.fields()
      • fields

        public final Field<?>[] fields​(Field<?>... f)
        Description copied from interface: Record
        Get all fields from this Record, providing some fields.
        Specified by:
        fields in interface Record
        Returns:
        All available fields
        See Also:
        Row.fields(Field...)
      • fields

        public final Field<?>[] fields​(String... fieldNames)
        Description copied from interface: Record
        Get all fields from this Record, providing some field names.
        Specified by:
        fields in interface Record
        Returns:
        All available fields
        See Also:
        Row.fields(String...)
      • fields

        public final Field<?>[] fields​(Name... fieldNames)
        Description copied from interface: Record
        Get all fields from this Record, providing some field names.
        Specified by:
        fields in interface Record
        Returns:
        All available fields
        See Also:
        Row.fields(Name...)
      • fields

        public final Field<?>[] fields​(int... fieldIndexes)
        Description copied from interface: Record
        Get all fields from this Record, providing some field indexes.
        Specified by:
        fields in interface Record
        Returns:
        All available fields
        See Also:
        Row.fields(int...)
      • indexOf

        public final int indexOf​(Field<?> field)
        Description copied from interface: Record
        Get a field's index from this record.
        Specified by:
        indexOf in interface Record
        Parameters:
        field - The field to look for
        Returns:
        The field's index or -1 if the field is not contained in this record.
      • indexOf

        public final int indexOf​(String fieldName)
        Description copied from interface: Record
        Get a field's index from this record.
        Specified by:
        indexOf in interface Record
        Parameters:
        fieldName - The field name to look for
        Returns:
        The field's index or -1 if the field is not contained in this record.
      • indexOf

        public final int indexOf​(Name fieldName)
        Description copied from interface: Record
        Get a field's index from this record.
        Specified by:
        indexOf in interface Record
        Parameters:
        fieldName - The field name to look for
        Returns:
        The field's index or -1 if the field is not contained in this record
      • size

        public final int size()
        Description copied from interface: Record
        Get the number of fields of this record.
        Specified by:
        size in interface Record
      • get

        public final <T> T get​(Field<T> field)
        Description copied from interface: Record
        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.

        Specified by:
        get in interface Record
        Type Parameters:
        T - The generic field parameter
        Parameters:
        field - The field
        Returns:
        The value of a field contained in this record
      • get

        public final <T> T get​(Field<?> field,
                               Class<? extends T> type)
        Description copied from interface: Record
        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.

        Specified by:
        get in interface Record
        Type Parameters:
        T - The conversion type parameter
        Parameters:
        field - The field
        type - The conversion type
        Returns:
        The value of a field contained in this record
        See Also:
        Convert.convert(Object, Class)
      • get

        public final <T,​U> U get​(Field<T> field,
                                       Converter<? super T,​? extends U> converter)
        Description copied from interface: Record
        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.

        Specified by:
        get in interface Record
        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
        See Also:
        Convert.convert(Object, Converter)
      • get

        public final Object get​(int index)
        Description copied from interface: Record
        Get a value from this record, providing a field index.
        Specified by:
        get in interface Record
        Parameters:
        index - The field's index
        Returns:
        The value of a field's index contained in this record
      • get

        public final <T> T get​(int index,
                               Class<? extends T> type)
        Description copied from interface: Record
        Get a converted value from this record, providing a field index.
        Specified by:
        get in interface Record
        Type Parameters:
        T - The conversion type parameter
        Parameters:
        index - The field's index
        type - The conversion type
        Returns:
        The value of a field's index contained in this record
        See Also:
        Convert.convert(Object, Class)
      • get

        public final <U> U get​(int index,
                               Converter<?,​? extends U> converter)
        Description copied from interface: Record
        Get a converted value from this record, providing a field index.
        Specified by:
        get in interface Record
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        index - The field's index
        converter - The data type converter
        Returns:
        The value of a field's index contained in this record
        See Also:
        Convert.convert(Object, Converter)
      • get

        public final Object get​(String fieldName)
        Description copied from interface: Record
        Get a value from this Record, providing a field name.
        Specified by:
        get in interface Record
        Parameters:
        fieldName - The field's name
        Returns:
        The value of a field's name contained in this record
      • get

        public final <T> T get​(String fieldName,
                               Class<? extends T> type)
        Description copied from interface: Record
        Get a converted value from this Record, providing a field name.
        Specified by:
        get in interface Record
        Type Parameters:
        T - The conversion type parameter
        Parameters:
        fieldName - The field's name
        type - The conversion type
        Returns:
        The value of a field's name contained in this record
        See Also:
        Convert.convert(Object, Class)
      • get

        public final <U> U get​(String fieldName,
                               Converter<?,​? extends U> converter)
        Description copied from interface: Record
        Get a converted value from this Record, providing a field name.
        Specified by:
        get in interface Record
        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
        See Also:
        Convert.convert(Object, Converter)
      • get

        public final Object get​(Name fieldName)
        Description copied from interface: Record
        Get a value from this Record, providing a field name.
        Specified by:
        get in interface Record
        Parameters:
        fieldName - The field's name
        Returns:
        The value of a field's name contained in this record
      • get

        public final <T> T get​(Name fieldName,
                               Class<? extends T> type)
        Description copied from interface: Record
        Get a converted value from this Record, providing a field name.
        Specified by:
        get in interface Record
        Type Parameters:
        T - The conversion type parameter
        Parameters:
        fieldName - The field's name
        type - The conversion type
        Returns:
        The value of a field's name contained in this record
        See Also:
        Convert.convert(Object, Class)
      • get

        public final <U> U get​(Name fieldName,
                               Converter<?,​? extends U> converter)
        Description copied from interface: Record
        Get a converted value from this Record, providing a field name.
        Specified by:
        get in interface Record
        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
        See Also:
        Convert.convert(Object, Converter)
      • setValue

        @Deprecated
        protected final void setValue​(int index,
                                      Object value)
        Deprecated.
        - Use AbstractRecord.set(int, Object) instead
        Subclasses may type-unsafely set a value to a record index. This method takes care of converting the value to the appropriate type.
      • set

        protected final void set​(int index,
                                 Object value)
      • set

        public final <T> void set​(Field<T> field,
                                  T value)
        Description copied from interface: Record
        Set a value into this record.

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

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

        Specified by:
        set in interface Record
        Type Parameters:
        T - The generic field parameter
        Parameters:
        field - The field
        value - The value
      • set

        public final <T,​U> void set​(Field<T> field,
                                          U value,
                                          Converter<? extends T,​? super U> converter)
        Description copied from interface: Record
        Set a value into this record.

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

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

        Specified by:
        set in interface Record
        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
      • original

        public final <T> T original​(Field<T> field)
        Description copied from interface: Record
        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.

        Specified by:
        original in interface Record
        See Also:
        Record.original()
      • original

        public final Object original​(int fieldIndex)
        Description copied from interface: Record
        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.

        Specified by:
        original in interface Record
        See Also:
        Record.original()
      • original

        public final Object original​(String fieldName)
        Description copied from interface: Record
        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.

        Specified by:
        original in interface Record
        See Also:
        Record.original()
      • original

        public final Object original​(Name fieldName)
        Description copied from interface: Record
        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.

        Specified by:
        original in interface Record
        See Also:
        Record.original()
      • changed

        public final boolean changed​(int fieldIndex)
        Description copied from interface: Record
        Check if a field's value has been changed from its original as fetched from the database.
        Specified by:
        changed in interface Record
        See Also:
        Record.changed(), Record.original(int)
      • changed

        public final void changed​(int fieldIndex,
                                  boolean c)
        Description copied from interface: Record
        Set this record's internal changed flag to the supplied value for a given field.

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

        Specified by:
        changed in interface Record
        See Also:
        Record.changed(), Record.changed(int)
      • changed

        public final void changed​(Name fieldName,
                                  boolean c)
        Description copied from interface: Record
        Set this record's internal changed flag to the supplied value for a given field.

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

        Specified by:
        changed in interface Record
        See Also:
        Record.changed(), Record.changed(Name)
      • intoArray

        public final Object[] intoArray()
        Description copied from interface: Record
        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)

        Specified by:
        intoArray in interface Record
        Returns:
        This record as an array
        See Also:
        Record.fromArray(Object...)
      • intoList

        public final List<Object> intoList()
        Description copied from interface: Record
        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())

        Specified by:
        intoList in interface Record
      • intoStream

        public final Stream<Object> intoStream()
        Description copied from interface: Record
        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)

        Specified by:
        intoStream in interface Record
        Returns:
        This record as a stream
      • into

        public final Record into​(Field<?>... f)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Parameters:
        f - The fields of the new record
        Returns:
        The new record
      • into

        public final <T1> Record1<T1> into​(Field<T1> field1)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2> Record2<T1,​T2> into​(Field<T1> field1,
                                                             Field<T2> field2)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3> Record3<T1,​T2,​T3> into​(Field<T1> field1,
                                                                               Field<T2> field2,
                                                                               Field<T3> field3)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4> Record4<T1,​T2,​T3,​T4> into​(Field<T1> field1,
                                                                                                 Field<T2> field2,
                                                                                                 Field<T3> field3,
                                                                                                 Field<T4> field4)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5> Record5<T1,​T2,​T3,​T4,​T5> into​(Field<T1> field1,
                                                                                                                   Field<T2> field2,
                                                                                                                   Field<T3> field3,
                                                                                                                   Field<T4> field4,
                                                                                                                   Field<T5> field5)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

        public final <T1,​T2,​T3,​T4,​T5,​T6,​T7,​T8,​T9,​T10,​T11,​T12,​T13,​T14,​T15,​T16,​T17,​T18,​T19> 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)
        Description copied from interface: Record
        Copy this record into a new record holding only a subset of the previous fields.
        Specified by:
        into in interface Record
        Returns:
        The new record
        See Also:
        Record.into(Table)
      • into

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

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

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

        public final <E> E into​(E object)
        Description copied from interface: Record
        Map resulting records onto a custom type.

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

        Specified by:
        into in interface Record
        Type Parameters:
        E - The generic entity type.
        Parameters:
        object - The receiving bean.
        See Also:
        Record.from(Object)
      • into

        public final <R extends Record> R into​(Table<R> table)
        Description copied from interface: Record
        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

        Specified by:
        into in interface Record
        Type Parameters:
        R - The generic table record type.
        Parameters:
        table - The table type.
      • map

        public final <E> E map​(RecordMapper<Record,​E> mapper)
        Description copied from interface: Record
        Map this record into a custom mapper callback.
        Specified by:
        map in interface Record
        Parameters:
        mapper - The mapper callback
        Returns:
        The custom mapped record
      • from

        public final void from​(Object source)
        Description copied from interface: Record
        Load data into this record from a source.

        The mapping algorithm is this:

        If source is an array

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

        If source is a Map

        Loading of data is delegated to Record.fromMap(Map)

        If source is an Iterable

        Loading of data is equivalent to loading Record.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())

        Specified by:
        from in interface Record
        Parameters:
        source - The source object to copy data from
        See Also:
        Record.into(Class), Record.from(Object, Field...)
      • from

        public final void from​(Object source,
                               Field<?>... f)
        Description copied from interface: Record
        Load data into this record from a source, providing some fields.

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

        Specified by:
        from in interface Record
        Parameters:
        source - The source object to copy data from
        f - The record's fields to use for mapping
        See Also:
        Record.into(Class), Record.from(Object)
      • from

        public final void from​(Object source,
                               String... fieldNames)
        Description copied from interface: Record
        Load data into this record from a source, providing some field names.

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

        Specified by:
        from in interface Record
        Parameters:
        source - The source object to copy data from
        fieldNames - The record's fields names to use for mapping
        See Also:
        Record.into(Class), Record.from(Object)
      • from

        public final void from​(Object source,
                               Name... fieldNames)
        Description copied from interface: Record
        Load data into this record from a source, providing some field names.

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

        Specified by:
        from in interface Record
        Parameters:
        source - The source object to copy data from
        fieldNames - The record's fields names to use for mapping
        See Also:
        Record.into(Class), Record.from(Object)
      • from

        public final void from​(Object source,
                               int... fieldIndexes)
        Description copied from interface: Record
        Load data into this record from a source, providing some field indexes.

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

        Specified by:
        from in interface Record
        Parameters:
        source - The source object to copy data from
        fieldIndexes - The record's fields indexes to use for mapping
        See Also:
        Record.into(Class), Record.from(Object)
      • fromMap

        public final void fromMap​(Map<String,​?> map)
        Description copied from interface: Record
        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 Record.field(String). Missing fields will be left untouched. Excess fields will be ignored.

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

        Specified by:
        fromMap in interface Record
        See Also:
        Record.intoMap(), Record.fromMap(Map, Field...)
      • fromMap

        public final void fromMap​(Map<String,​?> map,
                                  Field<?>... f)
        Description copied from interface: Record
        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 Record.field(String). Missing fields will be left untouched. Excess fields will be ignored.

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

        Specified by:
        fromMap in interface Record
        See Also:
        Record.intoMap(), Record.fromMap(Map)
      • fromMap

        public final void fromMap​(Map<String,​?> map,
                                  String... fieldNames)
        Description copied from interface: Record
        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 Record.field(String). Missing fields will be left untouched. Excess fields will be ignored.

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

        Specified by:
        fromMap in interface Record
        See Also:
        Record.intoMap(), Record.fromMap(Map)
      • fromMap

        public final void fromMap​(Map<String,​?> map,
                                  Name... fieldNames)
        Description copied from interface: Record
        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 Record.field(Name). Missing fields will be left untouched. Excess fields will be ignored.

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

        Specified by:
        fromMap in interface Record
        See Also:
        Record.intoMap(), Record.fromMap(Map)
      • fromMap

        public final void fromMap​(Map<String,​?> map,
                                  int... fieldIndexes)
        Description copied from interface: Record
        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 Record.field(String). Missing fields will be left untouched. Excess fields will be ignored.

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

        Specified by:
        fromMap in interface Record
        See Also:
        Record.intoMap(), Record.fromMap(Map)
      • fromArray

        public final void fromArray​(Object[] array,
                                    Field<?>... f)
        Description copied from interface: Record
        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 Record.fromArray(Object...), except that only fields contained in the fields argument will be mapped.

        Specified by:
        fromArray in interface Record
        See Also:
        Record.intoArray(), Record.fromArray(Object...)
      • fromArray

        public final void fromArray​(Object[] array,
                                    String... fieldNames)
        Description copied from interface: Record
        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 Record.fromArray(Object...), except that only fields contained in the fieldNames argument will be mapped.

        Specified by:
        fromArray in interface Record
        See Also:
        Record.intoArray(), Record.fromArray(Object...)
      • fromArray

        public final void fromArray​(Object[] array,
                                    Name... fieldNames)
        Description copied from interface: Record
        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 Record.fromArray(Object...), except that only fields contained in the fieldNames argument will be mapped.

        Specified by:
        fromArray in interface Record
        See Also:
        Record.intoArray(), Record.fromArray(Object...)
      • fromArray

        public final void fromArray​(Object[] array,
                                    int... fieldIndexes)
        Description copied from interface: Record
        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 Record.fromArray(Object...), except that only fields contained in the fieldIndexes argument will be mapped.

        Specified by:
        fromArray in interface Record
        See Also:
        Record.intoArray(), Record.fromArray(Object...)
      • from

        protected final void from​(Record source)
        This method was implemented with [#799]. It may be useful to make it public for broader use...?
      • compareTo

        public int compareTo​(Record that)
        Description copied from interface: 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>
        Specified by:
        compareTo in interface Record
      • getValue

        public final <T> T getValue​(Field<T> field)
        Description copied from interface: Record
        Get a value from this Record, providing a field.

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

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(Field)
      • getValue

        @Deprecated
        public final <T> T getValue​(Field<T> field,
                                    T defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a value from this record, providing a field.
        Specified by:
        getValue in interface Record
        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
      • getValue

        @Deprecated
        public final <T> T getValue​(Field<?> field,
                                    Class<? extends T> type,
                                    T defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a converted value from this record, providing a field.
        Specified by:
        getValue in interface Record
        Type Parameters:
        T - The conversion type parameter
        Parameters:
        field - The field
        type - The conversion type
        defaultValue - The default value instead of null
        Returns:
        The value of a field contained in this record, or defaultValue, if null
        See Also:
        Convert.convert(Object, Class)
      • getValue

        @Deprecated
        public final <T,​U> U getValue​(Field<T> field,
                                            Converter<? super T,​? extends U> converter,
                                            U defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a converted value from this record, providing a field.
        Specified by:
        getValue in interface Record
        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
        See Also:
        Convert.convert(Object, Converter)
      • getValue

        public final Object getValue​(int index)
        Description copied from interface: Record
        Get a value from this record, providing a field index.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use Record.get(int) instead.

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(int)
      • getValue

        @Deprecated
        public final Object getValue​(int index,
                                     Object defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a value from this record, providing a field index.
        Specified by:
        getValue in interface Record
        Parameters:
        index - The field's index
        defaultValue - The default value instead of null
        Returns:
        The value of a field's index contained in this record, or defaultValue, if null
      • getValue

        public final <T> T getValue​(int index,
                                    Class<? extends T> type)
        Description copied from interface: Record
        Get a converted value from this record, providing a field index.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use Record.get(int, Class) instead.

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(int, Class)
      • getValue

        @Deprecated
        public final <T> T getValue​(int index,
                                    Class<? extends T> type,
                                    T defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a converted value from this record, providing a field index.
        Specified by:
        getValue in interface Record
        Type Parameters:
        T - The conversion type parameter
        Parameters:
        index - The field's index
        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
        See Also:
        Convert.convert(Object, Class)
      • getValue

        public final <U> U getValue​(int index,
                                    Converter<?,​? extends U> converter)
        Description copied from interface: Record
        Get a converted value from this record, providing a field index.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use Record.get(int, Converter) instead.

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(int, Converter)
      • getValue

        @Deprecated
        public final <U> U getValue​(int index,
                                    Converter<?,​? extends U> converter,
                                    U defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a converted value from this record, providing a field index.
        Specified by:
        getValue in interface Record
        Type Parameters:
        U - The conversion type parameter
        Parameters:
        index - The field's index
        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
        See Also:
        Convert.convert(Object, Converter)
      • getValue

        public final Object getValue​(String fieldName)
        Description copied from interface: Record
        Get a value from this Record, providing a field name.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use Record.get(String) instead.

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(String)
      • getValue

        @Deprecated
        public final Object getValue​(String fieldName,
                                     Object defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a value from this record, providing a field name.
        Specified by:
        getValue in interface Record
        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
      • getValue

        @Deprecated
        public final <T> T getValue​(String fieldName,
                                    Class<? extends T> type,
                                    T defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a converted value from this record, providing a field name.
        Specified by:
        getValue in interface Record
        Type Parameters:
        T - 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
        See Also:
        Convert.convert(Object, Class)
      • getValue

        @Deprecated
        public final <U> U getValue​(String fieldName,
                                    Converter<?,​? extends U> converter,
                                    U defaultValue)
        Deprecated.
        Description copied from interface: Record
        Get a converted value from this record, providing a field name.
        Specified by:
        getValue in interface Record
        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
        See Also:
        Convert.convert(Object, Converter)
      • getValue

        public final Object getValue​(Name fieldName)
        Description copied from interface: Record
        Get a value from this Record, providing a field name.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use Record.get(Name) instead.

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(Name)
      • getValue

        public final <T> T getValue​(Name fieldName,
                                    Class<? extends T> type)
        Description copied from interface: Record
        Get a converted value from this Record, providing a field name.

        [#2211] Future versions of jOOQ might remove this method. It is recommended to use Record.get(Name, Class) instead.

        Specified by:
        getValue in interface Record
        See Also:
        Record.get(Name, Class)
      • attach

        public final void attach​(Configuration c)
        Description copied from interface: Attachable
        Attach this object to a new Configuration.
        Specified by:
        attach in interface Attachable
        Parameters:
        c - A configuration or null, if you wish to detach this Attachable from its previous configuration.
      • detach

        public final void detach()
        Description copied from interface: Attachable
        Detach this object from its current Configuration.

        This is the same as calling attach(null).

        Specified by:
        detach in interface Attachable
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object
      • format

        public final String format()
        Description copied from interface: Formattable
        Get a simple formatted representation of this result.

        This is the same as calling Formattable.format(int) with maxRows = Integer.MAX_VALUE

        Specified by:
        format in interface Formattable
        Returns:
        The formatted result
      • format

        public final String format​(int maxRecords)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result.
        Specified by:
        format in interface Formattable
        Parameters:
        maxRecords - The maximum number of records to include in the formatted result
        Returns:
        The formatted result
      • format

        public final String format​(TXTFormat format)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result.
        Specified by:
        format in interface Formattable
        Parameters:
        format - The formatting information
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV()
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.

        This is the same as calling formatCSV(true, ',', "")

        Specified by:
        formatCSV in interface Formattable
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV​(boolean header)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.

        This is the same as calling formatCSV(',', "")

        Specified by:
        formatCSV in interface Formattable
        Parameters:
        header - Whether to emit a CSV header line
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV​(char delimiter)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.

        This is the same as calling formatCSV(true, delimiter, "")

        Specified by:
        formatCSV in interface Formattable
        Parameters:
        delimiter - The delimiter to use between records
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV​(boolean header,
                                      char delimiter)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.

        This is the same as calling formatCSV(delimiter, "")

        Specified by:
        formatCSV in interface Formattable
        Parameters:
        header - Whether to emit a CSV header line
        delimiter - The delimiter to use between records
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV​(char delimiter,
                                      String nullString)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.

        This is the same as calling formatCSV(true, delimiter, nullString)

        Specified by:
        formatCSV in interface Formattable
        Parameters:
        delimiter - The delimiter to use between records
        nullString - A special string for encoding NULL values.
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV​(boolean header,
                                      char delimiter,
                                      String nullString)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.
        Specified by:
        formatCSV in interface Formattable
        Parameters:
        header - Whether to emit a CSV header line
        delimiter - The delimiter to use between records
        nullString - A special string for encoding NULL values.
        Returns:
        The formatted result
      • formatCSV

        public final String formatCSV​(CSVFormat format)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as CSV.
        Specified by:
        formatCSV in interface Formattable
        Returns:
        The formatted result
      • formatJSON

        public final String formatJSON()
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as a JSON array of array.

        The format is the following:

         {"fields":[{"name":"field-1","type":"type-1"},
                    {"name":"field-2","type":"type-2"},
                    ...,
                    {"name":"field-n","type":"type-n"}],
          "records":[[value-1-1,value-1-2,...,value-1-n],
                     [value-2-1,value-2-2,...,value-2-n]]}
         
        Specified by:
        formatJSON in interface Formattable
        Returns:
        The formatted result
      • formatJSON

        public final String formatJSON​(JSONFormat format)
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as a JSON data structure, according to the format.
        Specified by:
        formatJSON in interface Formattable
        Returns:
        The formatted result
        See Also:
        JSONFormat
      • formatInsert

        public final String formatInsert​(Table<?> table,
                                         Field<?>... f)
        Description copied from interface: Formattable
        Get this result as a set of INSERT statements.

        This explicitly specifies the table (and optionally the fields) to insert into. If the fields argument is left empty, the Result.fields() are used, instead.

        Specified by:
        formatInsert in interface Formattable
      • formatHTML

        public final String formatHTML()
        Description copied from interface: Formattable
        Get a simple formatted representation of this result as HTML.

        The HTML code is formatted as follows:

         <table>
           <thead>
             <tr>
               <th>field-1</th>
               <th>field-2</th>
               ...
               <th>field-n</th>
             </tr>
           </thead>
           <tbody>
             <tr>
               <th>value-1-1</th>
               <th>value-1-2</th>
               ...
               <th>value-1-n</th>
             </tr>
             <tr>
               <th>value-2-1</th>
               <th>value-2-2</th>
               ...
               <th>value-2-n</th>
             </tr>
             ...
           </tbody>
         </table>
         
        Specified by:
        formatHTML in interface Formattable
        Returns:
        The formatted result