UpdatableRecordImpl (jOOQ 3.0.1 API)

java.lang.Object
- org.jooq.impl.TableRecordImpl<R>
- - org.jooq.impl.UpdatableRecordImpl<R>

All Implemented Interfaces:

Serializable, Comparable<Record>, Attachable, AttachableInternal, Record, TableRecord<R>, UpdatableRecord<R>
```
public class UpdatableRecordImpl<R extends UpdatableRecord<R>>
extends TableRecordImpl<R>
implements UpdatableRecord<R>
```
A record implementation for a record holding a primary key
This type is for JOOQ INTERNAL USE only. Do not reference directly

Author:

Lukas Eder

See Also:
Serialized Form

Constructor Summary

Constructors
Constructor and Description

UpdatableRecordImpl(Table<R> table)

Constructors
Constructor and Description
`UpdatableRecordImpl(Table<R> table)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`attach(Configuration c)` Attach this object to a new `Configuration`
`boolean`	`changed()` Check if this record has been changed from its original as fetched from the database.
`void`	`changed(boolean changed)` Set all of this record's internal changed flags to the supplied value If the `changed` argument is `false`, the `Record.original()` values will be reset to the corresponding "current" values as well
`boolean`	`changed(Field<?> field)` Check if a field's value has been changed from its original as fetched from the database.
`void`	`changed(Field<?> field, boolean changed)` Set this record's internal changed flag to the supplied value for a given field.
`boolean`	`changed(int fieldIndex)` Check if a field's value has been changed from its original as fetched from the database.
`void`	`changed(int fieldIndex, boolean changed)` Set this record's internal changed flag to the supplied value for a given field.
`boolean`	`changed(String fieldName)` Check if a field's value has been changed from its original as fetched from the database.
`void`	`changed(String fieldName, boolean changed)` Set this record's internal changed flag to the supplied value for a given field.
`int`	`compareTo(Record that)` Compares this `Record` with another `Record` according to their natural ordering.
`Configuration`	`configuration()` Get the underlying configuration
`R`	`copy()` 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.
`protected DSLContext`	`create()` This method is used in generated code!
`int`	`delete()` Deletes this record from the database, based on the value of the primary key or main unique key.
`boolean`	`equals(Object obj)`
`<O extends TableRecord<O>> O`	`fetchChild(ForeignKey<O,R> key)` Fetch a child record of this record, given a foreign key This returns a child record referencing this record through a given foreign key.
`<O extends TableRecord<O>> Result<O>`	`fetchChildren(ForeignKey<O,R> key)` Fetch child records of this record, given a foreign key This returns childs record referencing this record through a given foreign key.
`<T> Field<T>`	`field(Field<T> field)` Get a specific field from this Record.
`Field<?>`	`field(int index)` Get a specific field from this Record.
`Field<?>`	`field(String name)` Get a specific field from this Record.
`Field<?>[]`	`fields()` Get all fields from this Record.
`void`	`from(Object source)` Load data into this record from a source.
`protected void`	`from(Record source)` This method was implemented with [#799].
`void`	`fromArray(Object... array)` Load data from an array into this record The argument array is expected to hold values for this record's field indexes.
`void`	`fromMap(Map<String,?> map)` Load data from a map into this record The argument map is expected to hold field-name / value pairs where field-names correspond to actual field names as provided by `Record.field(String)`.
`<T> T`	`getValue(Field<?> field, Class<? extends T> type)` Get a converted value from this Record, providing a field.
`<T> T`	`getValue(Field<?> field, Class<? extends T> type, T defaultValue)` Get a converted value from this record, providing a field.
`<T> T`	`getValue(Field<T> field)` Get a value from this Record, providing a field.
`<T,U> U`	`getValue(Field<T> field, Converter<? super T,U> converter)` Get a converted value from this Record, providing a field.
`<T,U> U`	`getValue(Field<T> field, Converter<? super T,U> converter, U defaultValue)` Get a converted value from this record, providing a field.
`<T> T`	`getValue(Field<T> field, T defaultValue)` Get a value from this record, providing a field.
`Object`	`getValue(int index)` This method coincides with `Record.getValue(int)` and `ArrayRecordImpl.getValue(int)`
`<T> T`	`getValue(int index, Class<? extends T> type)` Get a converted value from this record, providing a field index.
`<T> T`	`getValue(int index, Class<? extends T> type, T defaultValue)` Get a converted value from this record, providing a field index.
`<U> U`	`getValue(int index, Converter<?,U> converter)` Get a converted value from this record, providing a field index.
`<U> U`	`getValue(int index, Converter<?,U> converter, U defaultValue)` Get a converted value from this record, providing a field index.
`Object`	`getValue(int index, Object defaultValue)` Get a value from this record, providing a field index.
`Object`	`getValue(String fieldName)` Get a value from this Record, providing a field name.
`<T> T`	`getValue(String fieldName, Class<? extends T> type)` Get a converted value from this Record, providing a field name.
`<T> T`	`getValue(String fieldName, Class<? extends T> type, T defaultValue)` Get a converted value from this record, providing a field name.
`<U> U`	`getValue(String fieldName, Converter<?,U> converter)` Get a converted value from this Record, providing a field name.
`<U> U`	`getValue(String fieldName, Converter<?,U> converter, U defaultValue)` Get a converted value from this record, providing a field name.
`Object`	`getValue(String fieldName, Object defaultValue)` Get a value from this record, providing a field name.
`int`	`hashCode()`
`int`	`insert()` Store this record back to the database using an `INSERT` statement.
`<E> E`	`into(Class<? extends E> type)` Map resulting records onto a custom type.
`<E> E`	`into(E object)` Map resulting records onto a custom type.
`<R extends Record> R`	`into(Table<R> table)` Map resulting records onto a custom record type.
`Object[]`	`intoArray()` Convert this record into an array.
`Map<String,Object>`	`intoMap()` Return this record as a name/value map.
`ResultSet`	`intoResultSet()` Generate an in-memory JDBC `ResultSet` containing the data of this `Record`.
`Record`	`key()` A view holding values for the `Table.getPrimaryKey()` This method returns a "view" of this record itself.
`<E> E`	`map(RecordMapper<Record,E> mapper)` Map this record into a custom mapper callback
`<T> T`	`original(Field<T> field)` Get an original value from this record as fetched from the database.
`Object`	`original(int fieldIndex)` Get an original value from this record as fetched from the database.
`Object`	`original(String fieldName)` Get an original value from this record as fetched from the database.
`void`	`refresh()` Refresh this record from the database, based on the value of the primary key or main unique key.
`void`	`refresh(Field<?>... f)` Refresh this record from the database, based on the value of the primary key or main unique key.
`void`	`reset()` Reset all values to their `Record.original()` values and all `Record.changed()` flags to `false`.
`void`	`reset(Field<?> field)` Reset a given value to its `Record.original(Field)` value and its `Record.changed(Field)` flag to `false`.
`void`	`reset(int fieldIndex)` Reset a given value to its `Record.original(int)` value and its `Record.changed(int)` flag to `false`.
`void`	`reset(String fieldName)` Reset a given value to its `Record.original(String)` value and its `Record.changed(String)` flag to `false`.
`<T> void`	`setValue(Field<T> field, T value)` Set a value into this record.
`<T,U> void`	`setValue(Field<T> field, U value, Converter<T,? super U> converter)` Set a value into this record.
`protected void`	`setValue(int index, Object value)` Subclasses may type-unsafely set a value to a record index.
`int`	`size()` This method coincides with `Record.size()` and `ArrayRecord.size()`
`int`	`store()` Store this record back to the database.
`String`	`toString()`
`int`	`update()` Store this record back to the database using an `UPDATE` statement.

Methods inherited from class org.jooq.impl.TableRecordImpl
fetchParent, fieldsRow, getTable, original, valuesRow

Methods inherited from class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.jooq.TableRecord
fetchParent, getTable, original

Methods inherited from interface org.jooq.Record
changed, changed, changed, changed, changed, changed, changed, changed, compareTo, equals, field, field, field, fields, fieldsRow, from, fromArray, fromMap, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, getValue, hashCode, into, into, into, intoArray, intoMap, intoResultSet, map, original, original, original, reset, reset, reset, reset, setValue, setValue, size, valuesRow

Methods inherited from interface org.jooq.Attachable
attach

- Constructor Detail
  - UpdatableRecordImpl
```
public UpdatableRecordImpl(Table<R> table)
```
- Method Detail
  - key
```
public Record key()
```
    Description copied from interface: UpdatableRecord
    
    A view holding values for the Table.getPrimaryKey()
    This method returns a "view" of this record itself. Modifications to the returned record will affect values in this record.
    The returned record consists exactly of those fields as returned by the table's primary key: Key.getFields().
    Generated subtypes may covariantly override this method to add more record type information. For instance, they may return Record1, Record2, ...
    
    Specified by:
    
    key in interface UpdatableRecord<R extends UpdatableRecord<R>>
  - fetchChild
```
public final <O extends TableRecord<O>> O fetchChild(ForeignKey<O,R> key)
```
    Description copied from interface: UpdatableRecord
    
    Fetch a child record of this record, given a foreign key
    This returns a child record referencing this record through a given foreign key. If no child record was found, this returns null
    
    Specified by:
    
    fetchChild in interface UpdatableRecord<R extends UpdatableRecord<R>>
    
    See Also:
    ForeignKey.fetchChildren(java.util.Collection), ForeignKey.fetchChildren(Record), ForeignKey.fetchChildren(Record...)
  - fetchChildren
```
public final <O extends TableRecord<O>> Result<O> fetchChildren(ForeignKey<O,R> key)
```
    Description copied from interface: UpdatableRecord
    
    Fetch child records of this record, given a foreign key
    This returns childs record referencing this record through a given foreign key.
    
    Specified by:
    
    fetchChildren in interface UpdatableRecord<R extends UpdatableRecord<R>>
    
    See Also:
    ForeignKey.fetchChildren(java.util.Collection), ForeignKey.fetchChildren(Record), ForeignKey.fetchChildren(Record...)
  - 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 or main unique 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, but the primary key value was changed, an INSERT statement is executed. 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:
      
      SQLDialect.CUBRID and SQLDialect.SQLSERVER: jOOQ will try to lock the database record using JDBC's ResultSet.TYPE_SCROLL_SENSITIVE and ResultSet.CONCUR_UPDATABLE.
      
      SQLDialect.SQLITE: No pessimistic locking is possible. Client code must assure that no race-conditions can occur between jOOQ's checking of database record state and the actual UPDATE
      
      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]
    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()
  - insert
```
public final int insert()
```
    Description copied from interface: UpdatableRecord
    
    Store this record back to the database using an INSERT statement.
    This is the same as UpdatableRecord.store(), except that an INSERT statement (or no statement) will always be executed.
    
    Specified by:
    
    insert 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()
  - 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.
    
    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:
      
      SQLDialect.CUBRID and SQLDialect.SQLSERVER: jOOQ will try to lock the database record using JDBC's ResultSet.TYPE_SCROLL_SENSITIVE and ResultSet.CONCUR_UPDATABLE.
      
      SQLDialect.SQLITE: No pessimistic locking is possible. Client code must assure that no race-conditions can occur between jOOQ's checking of database record state and the actual DELETE
      
      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()
```
    Description copied from interface: UpdatableRecord
    Refresh this record from the database, based on the value of the primary key or main unique key.
    This is in fact the same as calling refresh(getFields().toArray(new Field[0]))
    The executed statement is
```
 SELECT * FROM [table]
 WHERE [primary key fields = primary key values]
```
    Specified by:
    
    refresh in interface UpdatableRecord<R extends UpdatableRecord<R>>
  - refresh
```
public final void refresh(Field<?>... f)
```
    Description copied from interface: UpdatableRecord
    Refresh this record from the database, based on the value of the primary key or main unique key.
    The executed statement is
```
 SELECT [fields] FROM [table]
 WHERE [primary key fields = primary key values]
```
    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.
    
    Specified by:
    
    field in interface Record
    
    See Also:
    Row.field(Field)
  - field
```
public final Field<?> field(String name)
```
    Description copied from interface: Record
    
    Get a specific field from this Record.
    
    Specified by:
    
    field in interface Record
    
    See Also:
    Row.field(String)
  - 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()
  - size
```
public final int size()
```
    This method coincides with Record.size() and ArrayRecord.size()
    
    Specified by:
    
    size 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.
    
    Specified by:
    
    getValue in interface Record
    
    Type Parameters:
    T - The generic field parameter
    Parameters:
    field - The field
    
    Returns:
    The value of a field contained in this record
  - getValue
```
public final <T> T getValue(Field<T> field,
             T defaultValue)
```
    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
```
public final <T> T getValue(Field<?> field,
             Class<? extends T> type)
```
    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
    
    Returns:
    The value of a field contained in this record
    See Also:
    Convert.convert(Object, Class)
  - getValue
```
public final <T> T getValue(Field<?> field,
             Class<? extends T> type,
             T defaultValue)
```
    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
```
public final <T,U> U getValue(Field<T> field,
               Converter<? super T,U> converter)
```
    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
    
    Returns:
    The value of a field contained in this record
    See Also:
    Convert.convert(Object, Converter)
  - getValue
```
public final <T,U> U getValue(Field<T> field,
               Converter<? super T,U> converter,
               U defaultValue)
```
    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)
```
    This method coincides with Record.getValue(int) and ArrayRecordImpl.getValue(int)
    
    Specified by:
    
    getValue in interface Record
    
    Parameters:
    index - The field's index
    
    Returns:
    The value of a field's index contained in this record
  - getValue
```
public final Object getValue(int index,
              Object defaultValue)
```
    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.
    
    Specified by:
    
    getValue 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)
  - getValue
```
public final <T> T getValue(int index,
             Class<? extends T> type,
             T defaultValue)
```
    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<?,U> converter)
```
    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
    
    Returns:
    The value of a field's index contained in this record
    See Also:
    Convert.convert(Object, Converter)
  - getValue
```
public final <U> U getValue(int index,
             Converter<?,U> converter,
             U defaultValue)
```
    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.
    
    Specified by:
    
    getValue in interface Record
    
    Parameters:
    fieldName - The field's name
    
    Returns:
    The value of a field's name contained in this record
  - getValue
```
public final Object getValue(String fieldName,
              Object defaultValue)
```
    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
```
public final <T> T getValue(String fieldName,
             Class<? extends T> type)
```
    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
    
    Returns:
    The value of a field's name contained in this record
    See Also:
    Convert.convert(Object, Class)
  - getValue
```
public final <T> T getValue(String fieldName,
             Class<? extends T> type,
             T defaultValue)
```
    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
```
public final <U> U getValue(String fieldName,
             Converter<?,U> converter)
```
    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
    
    Returns:
    The value of a field's name contained in this record
    See Also:
    Convert.convert(Object, Converter)
  - getValue
```
public final <U> U getValue(String fieldName,
             Converter<?,U> converter,
             U defaultValue)
```
    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)
  - setValue
```
public final <T> void setValue(Field<T> field,
                T value)
```
    Description copied from interface: Record
    
    Set a value into this record.
    
    Specified by:
    
    setValue in interface Record
    
    Type Parameters:
    T - The generic field parameter
    Parameters:
    field - The field
    value - The value
  - setValue
```
public final <T,U> void setValue(Field<T> field,
                  U value,
                  Converter<T,? super U> converter)
```
    Description copied from interface: Record
    
    Set a value into this record.
    
    Specified by:
    
    setValue 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
  - setValue
```
protected final void setValue(int index,
            Object value)
```
    Subclasses may type-unsafely set a value to a record index. This method takes care of converting the value to the 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()
  - changed
```
public final boolean changed()
```
    Description copied from interface: Record
    
    Check if this record has been changed from its original as fetched from the database.
    If this returns false, then it can be said that record.equals(record.original()) is true.
    
    Specified by:
    
    changed in interface Record
    
    See Also:
    Record.original(), Record.changed(Field), Record.changed(int), Record.changed(String)
  - changed
```
public final boolean changed(Field<?> field)
```
    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(Field)
  - 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 boolean changed(String fieldName)
```
    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(String)
  - changed
```
public final void changed(boolean changed)
```
    Description copied from interface: Record
    
    Set all of this record's internal changed flags to the supplied value
    If the changed argument is false, the Record.original() values will be reset to the corresponding "current" values as well
    
    Specified by:
    
    changed in interface Record
    
    See Also:
    Record.changed(), Record.changed(Field, boolean), Record.changed(int, boolean), Record.changed(String, boolean)
  - changed
```
public final void changed(Field<?> field,
           boolean changed)
```
    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(Field) value will be reset to the corresponding "current" value as well
    
    Specified by:
    
    changed in interface Record
    
    See Also:
    Record.changed(), Record.changed(Field)
  - changed
```
public final void changed(int fieldIndex,
           boolean changed)
```
    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(String fieldName,
           boolean changed)
```
    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(String) value will be reset to the corresponding "current" value as well
    
    Specified by:
    
    changed in interface Record
    
    See Also:
    Record.changed(), Record.changed(String)
  - reset
```
public final void reset()
```
    Description copied from interface: Record
    
    Reset all values to their Record.original() values and all Record.changed() flags to false.
    
    Specified by:
    
    reset in interface Record
  - reset
```
public final void reset(Field<?> field)
```
    Description copied from interface: Record
    
    Reset a given value to its Record.original(Field) value and its Record.changed(Field) flag to false.
    
    Specified by:
    
    reset in interface Record
  - reset
```
public final void reset(int fieldIndex)
```
    Description copied from interface: Record
    
    Reset a given value to its Record.original(int) value and its Record.changed(int) flag to false.
    
    Specified by:
    
    reset in interface Record
  - reset
```
public final void reset(String fieldName)
```
    Description copied from interface: Record
    
    Reset a given value to its Record.original(String) value and its Record.changed(String) flag to false.
    
    Specified by:
    
    reset in interface Record
  - 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...)
  - intoMap
```
public final Map<String,Object> intoMap()
```
    Description copied from interface: Record
    
    Return this record as a name/value map.
    This is the inverse operation to Record.fromMap(Map)
    
    Specified by:
    
    intoMap in interface Record
    
    Returns:
    This record as a map
    See Also:
    Record.fromMap(Map)
  - into
```
public final <E> E into(Class<? extends E> type)
```
    Description copied from interface: Record
    Map resulting records onto a custom type.
    The mapping algorithm is this:
    
    If type is an array:
    
    The resulting array is of the nature described in Record.intoArray(). Arrays more specific than Object[] can be specified as well, e.g. String[]. If conversion fails, a MappingException is thrown, wrapping conversion exceptions.
    
    If a default constructor is available and any JPA Column annotations are found on the provided type, only those are used:
    - If type contains public single-argument instance methods annotated with Column, those methods are invoked
    - If type contains public no-argument instance methods starting with getXXX or isXXX, annotated with Column, then matching public setXXX() instance methods are invoked
    - If type contains public instance member fields annotated with Column, those members are set
    Additional rules:
    - The same annotation can be re-used for several methods/members
    - Column.name() must match Field.getName(). All other annotation attributes are ignored
    - Static methods / member fields are ignored
    - Final member fields are ignored
    If a default constructor is available and if there are no JPA Column annotations, or jOOQ can't find the javax.persistence API on the classpath, jOOQ will map Record values by naming convention:
    
    If Field.getName() is MY_field (case-sensitive!), then this field's value will be set on all of these:
    - Public single-argument instance method MY_field(...)
    - Public single-argument instance method myField(...)
    - Public single-argument instance method setMY_field(...)
    - Public single-argument instance method setMyField(...)
    - Public non-final instance member field MY_field
    - Public non-final instance member field myField
    If no default constructor is available, but at least one constructor annotated with ConstructorProperties is available, that one is used
    - The standard JavaBeans ConstructorProperties annotation is used to match constructor arguments against POJO members or getters.
    - If those POJO members or getters have JPA annotations, those will be used according to the aforementioned rules, in order to map Record values onto constructor arguments.
    - If those POJO members or getters don't have JPA annotations, the aforementioned naming conventions will be used, in order to map Record values onto constructor arguments.
    - When several annotated constructors are found, the first one is chosen (as reported by Class.getDeclaredConstructors()
    - When invoking the annotated constructor, values are converted onto constructor argument types
    If no default constructor is available, but at least one "matching" constructor is available, that one is used
    - A "matching" constructor is one with exactly as many arguments as this record holds fields
    - When several "matching" constructors are found, the first one is chosen (as reported by Class.getDeclaredConstructors()
    - When invoking the "matching" constructor, values are converted onto constructor argument types
    If the supplied type is an interface or an abstract class
    
    Abstract types are instanciated using Java reflection Proxy mechanisms. The returned proxy will wrap a HashMap containing properties mapped by getters and setters of the supplied type. Methods (even JPA-annotated ones) other than standard POJO getters and setters are not supported. Details can be seen in Reflect.as(Class).
    
    Other restrictions
    - type must provide a default or a "matching" constructor. Non-public default constructors are made accessible using AccessibleObject.setAccessible(boolean)
    - primitive types are supported. If a value is null, this will result in setting the primitive type's default value (zero for numbers, or false for booleans). Hence, there is no way of distinguishing null and 0 in that case.
    Specified by:
    
    into in interface Record
    
    Type Parameters:
    E - The generic entity type.
    Parameters:
    type - The entity type.
    See Also:
    Record.from(Object)
  - 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 instanciated 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
    - Table.getRecordType() must return a class of type TableRecord, which must provide a default constructor. Non-public default constructors are made accessible using AccessibleObject.setAccessible(boolean)
    Specified by:
    
    into in interface Record
    
    Type Parameters:
    R - The generic table record type.
    Parameters:
    table - The table type.
  - intoResultSet
```
public final ResultSet intoResultSet()
```
    Description copied from interface: Record
    Generate an in-memory JDBC ResultSet containing the data of this Record.
    Use this as an adapter for JDBC-compliant code that expects a ResultSet to operate on, rather than a jOOQ Result. The returned ResultSet allows for the following behaviour according to the JDBC specification:
    - ResultSet.CLOSE_CURSORS_AT_COMMIT: The cursors (i.e. Statement object) are no longer available
    - ResultSet.CONCUR_READ_ONLY: You cannot update the database through this ResultSet, as the underlying Result object does not hold any open database refences anymore
    - ResultSet.FETCH_FORWARD: The fetch direction is forward only, and cannot be changed
    - ResultSet.TYPE_SCROLL_INSENSITIVE: You can use any of the ResultSet's scrolling methods, e.g. ResultSet.next() or ResultSet.previous(), etc.
    You may use DSLContext.fetch(ResultSet) to unwind this wrapper again.
    This is the same as creating a new Result with this Record only, and then calling Result.intoResultSet() on that Result
    Specified by:
    
    intoResultSet in interface Record
    
    Returns:
    A wrapper JDBC ResultSet
  - 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 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.
    Specified by:
    
    from in interface Record
    
    Parameters:
    source - The source object to copy data from
    See Also:
    Record.into(Class)
  - 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()
    
    Specified by:
    
    fromMap in interface Record
    
    See Also:
    Record.intoMap()
  - fromArray
```
public final void fromArray(Object... array)
```
    Description copied from interface: Record
    
    Load data from an array into this record
    The argument array is expected to hold values for this record's field indexes. Missing values will be left untouched. Excess values will be ignored.
    This is the inverse operation to Record.intoArray()
    
    Specified by:
    
    fromArray in interface Record
  - from
```
protected final void from(Record source)
```
    This method was implemented with [#799]. It may be useful to make it public for broader use...?
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - 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
  - 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.
  - configuration
```
public final Configuration configuration()
```
    Description copied from interface: AttachableInternal
    
    Get the underlying configuration
    
    Specified by:
    
    configuration in interface AttachableInternal
  - create
```
protected final DSLContext create()
```
    This method is used in generated code!
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object

Class UpdatableRecordImpl<R extends UpdatableRecord<R>>

Constructor Summary

Method Summary

Methods inherited from class org.jooq.impl.TableRecordImpl

Methods inherited from class java.lang.Object

Methods inherited from interface org.jooq.TableRecord

Methods inherited from interface org.jooq.Record

Methods inherited from interface org.jooq.Attachable

Constructor Detail

UpdatableRecordImpl

Method Detail

key

fetchChild

fetchChildren

store

Statement type

Automatic value generation

Optimistic locking

Statement examples

insert

update

delete

Optimistic locking

Statement examples

refresh

refresh

copy

field

field

field

fields

size

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

getValue

setValue

setValue

setValue

original

original

original

changed

changed

changed

changed

changed

changed

changed

changed

reset

reset

reset

reset

intoArray

intoMap

into

If type is an array:

If a default constructor is available and any JPA Column annotations are found on the provided type, only those are used:

If a default constructor is available and if there are no JPA Column annotations, or jOOQ can't find the javax.persistence API on the classpath, jOOQ will map Record values by naming convention:

If no default constructor is available, but at least one constructor annotated with ConstructorProperties is available, that one is used

If no default constructor is available, but at least one "matching" constructor is available, that one is used

If the supplied type is an interface or an abstract class

Other restrictions

into

into

If `type` is an array:

If a default constructor is available and any JPA `Column` annotations are found on the provided `type`, only those are used:

If a default constructor is available and if there are no JPA `Column` annotations, or jOOQ can't find the `javax.persistence` API on the classpath, jOOQ will map `Record` values by naming convention:

If no default constructor is available, but at least one constructor annotated with `ConstructorProperties` is available, that one is used

jOOQ will map `Record` values by equal field names:

If `source` is an `array`

If `source` is a `Map`

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

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: