BaseRecord (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.persist.orm.BaseRecord

All Implemented Interfaces:

DmoState, Persistable

Direct Known Subclasses:

Record
```
public abstract class BaseRecord
extends java.lang.Object
implements DmoState, Persistable
```
Base record class which stores data and current state for a single record, and which provides services to application-specific, DMO implementation subclasses.
Access to the internal state of this class is not thread-safe. Thus, instances are not intended to be accessed from more than one thread.

Field Summary

Fields
Modifier and Type	Field and Description
`private RecordBuffer`	`activeBuffer` The currently active buffer when state is changing
`protected int`	`activeOffset` The offset of the property currently being modified, if any (else `-1`)
`private java.lang.Object`	`activePropPreviousValue` The most recent value of the property currently being modified, for rollback purposes
`private ChangeSet`	`changeSet` Object which tracks change to enable rollback of the record's data and state
`protected java.lang.Object[]`	`data` The data represented by this record, in it's low-level (database friendly) form
`private java.util.BitSet`	`dirtyProps` Map of properties touched, each bit corresponds with a property in the data array
`protected java.lang.Long`	`id` Surrogate primary key of the record
`private IndexState`	`indexState` Tracker to manage which indices have been updated by property updates
`private static CentralLogger`	`LOG` Logger
`private java.util.BitSet`	`nullProps` Map of properties currently set to null, indicating unknown value
`static java.lang.reflect.Method`	`PK_GETTER` The cached getter method for the PK property.
`protected java.util.BitSet`	`readFields` For an incomplete record, this holds the fields which were read or assigned in this record.
`private RecordIdentifier<java.lang.String>`	`recid` Record identifier (lock variant, which uses table name) for this record (created lazily)
`protected long`	`references` Count of references to this DMO; while positive, it must remain in the current session cache.
`private java.util.concurrent.atomic.AtomicIntegerArray`	`sharedVersion` Shared version data structure, for version updates and stale checks
`protected RecordState`	`state` Current state of the record
`private java.util.BitSet`	`unvalidated` Map of properties currently requiring validation
`private int`	`version` Current version number, for stale checks

Fields inherited from interface com.goldencode.p2j.persist.orm.DmoState
CACHED, CHANGED, COPY, DEFAULT, DELETED, DELETING, INCOMPLETE, INVALID, NEW, NOUNDO, READ, STALE, TRACKED

Constructor Summary

Constructors
Modifier Constructor and Description

protected BaseRecord()
Default constructor which can only be invoked by subclasses.

Constructors
Modifier	Constructor and Description
`protected`	`BaseRecord()` Default constructor which can only be invoked by subclasses.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`java.util.BitSet`	`_getReadFields()` Get the `readFields`.
`protected abstract RecordMeta`	`_recordMeta()` Get the static record metadata for the concrete subclass.
`private void`	`bulkDataChanged(java.util.List<java.lang.Integer> offsets, java.util.List<java.lang.Object> datums)` Multiple property values have changed.
`protected void`	`checkIncomplete(int index)` Check if for an incomplete record, the specified field was read or assigned.
`boolean`	`checkState(int flags)` Checks whether a set of record state flags are set for this record.
`(package private) void`	`clearDirtyState(Session session)` Reset record and property state after database is synchronized with the record's data (i.e., the most recent set of changes have been persisted).
`(package private) void`	`commit()` The current application transaction has been committed.
`void`	`copy(BaseRecord from)` Makes this a copy of a source `BaseRecord` object.
`static boolean`	`copy(BaseRecord to, BaseRecord from, boolean b4reserved)` Copy the source record to the destination record.
`private void`	`dataChanged(int offset, java.lang.Object datum)` A property's value has changed.
`BaseRecord`	`deepCopy()` Copy this record's data and record state, including its primary key.
`(package private) int`	`getActiveOffset()` Get the offset of the property currently being updated, if any.
`java.lang.Object[]`	`getActiveUpdateDiffs()` Get a two element array representing the old and new values of the property currently being changed.
`protected java.lang.String`	`getCodePage(int offset)` Obtain the codepage of the `clob` object at position `offset`.
`java.lang.Object[]`	`getData(PropertyMapper pm)` This accessor allows direct access to private `data` array only to instances of `PropertyMapper`.
`java.lang.Object[]`	`getData(RecordBuffer rb)` This accessor allows direct access to private `data` array only to instances of `RecordBuffer`.
`protected java.lang.Object`	`getDatum(int offset)` Get the field's value on the specified offset.
`private java.util.BitSet`	`getDirtyIndices(java.util.BitSet[] indices, int dirtyOffset, java.util.BitSet filter, boolean full)` Get a bit set representing dirty unique or non-unique indices, subject to the conditions described by the parameters.
`java.util.BitSet`	`getDirtyIndices(int dirtyOffset, boolean unique, boolean remaining)` Get a bit set representing dirty unique or non-unique indices, subject to the conditions described by the parameters.
`java.util.BitSet`	`getDirtyProps()` Return the set of bits which are marked dirty.
`IndexState`	`getIndexState()` Get the update state of this record's indices.
`(package private) java.util.BitSet`	`getNullProps()` Get a bit set indicating the positions of data elements which currently are set to `null`.
`RecordIdentifier<java.lang.String>`	`getRecordLockIdentifier()` Get the unique identifier for this record, comprised of its table name and primary key.
`long`	`getSize()` Get the size of the record.
`private java.lang.String`	`getTable()` Get the name of the primary table associated with this record.
`(package private) java.util.BitSet`	`getUnvalidatedIndices(int dirtyOffset, boolean allUnvalidated)` Get a bit set representing the unique indices, if any, which are either fully or partially updated and which have not already been validated.
`(package private) void`	`indexUpdated(int idxUid)` An index was updated.
`void`	`initialize(boolean setDefaults)` Initialize this record instance, by setting all fields to their default values and also initializing the `indexState`, `unvalidated` and `nullProps` states.
`void`	`initialize(Session session, boolean setDefaults)` Populate the record's data with its default, initial values and update the record and property states accordingly.
`boolean`	`isAnyIndexFullyDirty()` Indicate whether all index components for any index on this record are dirty (i.e., have been touched, not necessarily changed..
`(package private) boolean`	`isAnyIndexFullyDirty(java.util.BitSet[] indices)` Compare the bitsets in the given array with the bitset of dirty properties for this record and indicate whether all index components for any index in the array are dirty.
`boolean`	`isDirty()` Indicate whether any property in the record currently is dirty (i.e., touched, not necessarily changed).
`boolean`	`isIndexed()` Report whether the table associated with this record has any (legacy) index.
`boolean`	`isInUse()` Indicate whether this DMO is "in use"; that is, whether buffers reference it or it is being tracked for UNDO processing.
`(package private) boolean`	`isPropertyDirty(int offset)` Indicate whether the property at the given offset in the DMO's data array is dirty (i.e., has been touched, but not necessarily changed).
`(package private) boolean`	`isStale()` Indicate whether this record's data is stale, based on changes committed by other user contexts.
`boolean`	`isValid()` Indicate whether the record has passed validation.
`private boolean`	`lockForUpdate()` Obtain an exclusive lock for the current record on behalf of the active buffer, if any.
`(package private) void`	`markIncomplete(Session session)` Mark this record as incomplete.
`(package private) void`	`markValidated()` Mark all dirty properties as having been validated.
`(package private) void`	`markValidated(int bit)` Mark a single property as having been validated.
`boolean`	`needsValidation()` Indicate whether any of this record's validatable properties are dirty and have not been validated.
`private int`	`prepareChangeSet(Session session)` If this is the first update to this record since an application transaction began, prepare a change set to track updates made to the record during the transaction, to be used for full or sub-transaction rollback, if needed.
`java.lang.Long`	`primaryKey()` Get the database identifier for this persistable object.
`void`	`primaryKey(java.lang.Long id)` Set the database identifier for this persistable object (i.e., surrogate primary key).
`(package private) int`	`readProperty(int propOffset, java.sql.ResultSet rs, int rsOffset)` Read a property directly from a `ResultSet`.
`(package private) int`	`readProperty(int propOffset, java.sql.ResultSet rs, int rsOffset, boolean skip)` Read a property directly from a `ResultSet`.
`void`	`restoreActiveState()` Restore to default active buffer, offset, and datum value.
`(package private) void`	`rollback(int txLevel)` Perform a full or sub-transaction level rollback of this record to its state as it was immediately before the block of the specified transaction nesting level was entered.
`java.lang.Runnable`	`setActiveBuffer(RecordBuffer buffer)` Set the record buffer which is currently active for this record.
`protected boolean`	`setAllData(BaseRecord source)` Set all data in the data array.
`protected void`	`setDatum(int offset, java.lang.Object datum)` Set a single datum into the data array, and update the record and property state accordingly.
`java.lang.String`	`toString()` Return a string representation of this object, primarily for debug purposes.
`java.lang.String`	`toString(boolean includeData)` Return a string representation of this object, primarily for debug purposes, optionally including the record's data in the output.
`void`	`undoActive()`
`private void`	`updateState(int flags, boolean set)` Updates the set of state flags for this record.
`void`	`updateState(Session session, int flags, boolean set)` Updates the set of state flags for this record.
`(package private) void`	`version(java.util.concurrent.atomic.AtomicIntegerArray sharedVersion)` Set this record's version to the canonical, shared version number for this record.

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

- Field Detail
  - LOG
```
private static final CentralLogger LOG
```
    Logger
  - PK_GETTER
```
public static final java.lang.reflect.Method PK_GETTER
```
    The cached getter method for the PK property.
  - id
```
protected java.lang.Long id
```
    Surrogate primary key of the record
  - data
```
protected final java.lang.Object[] data
```
    The data represented by this record, in it's low-level (database friendly) form
  - readFields
```
protected java.util.BitSet readFields
```
    For an incomplete record, this holds the fields which were read or assigned in this record.
  - state
```
protected final RecordState state
```
    Current state of the record
  - references
```
protected long references
```
    Count of references to this DMO; while positive, it must remain in the current session cache. The 4 high bytes represent the number of buffers the record is transiently loaded in. The 4 low bytes represent the number of active buffers the record is loaded in.
  - dirtyProps
```
private final java.util.BitSet dirtyProps
```
    Map of properties touched, each bit corresponds with a property in the data array
  - unvalidated
```
private final java.util.BitSet unvalidated
```
    Map of properties currently requiring validation
  - nullProps
```
private final java.util.BitSet nullProps
```
    Map of properties currently set to null, indicating unknown value
  - indexState
```
private final IndexState indexState
```
    Tracker to manage which indices have been updated by property updates
  - recid
```
private RecordIdentifier<java.lang.String> recid
```
    Record identifier (lock variant, which uses table name) for this record (created lazily)
  - activeBuffer
```
private RecordBuffer activeBuffer
```
    The currently active buffer when state is changing
  - activeOffset
```
protected int activeOffset
```
    The offset of the property currently being modified, if any (else -1)
  - activePropPreviousValue
```
private java.lang.Object activePropPreviousValue
```
    The most recent value of the property currently being modified, for rollback purposes
  - changeSet
```
private ChangeSet changeSet
```
    Object which tracks change to enable rollback of the record's data and state
  - version
```
private int version
```
    Current version number, for stale checks
  - sharedVersion
```
private transient java.util.concurrent.atomic.AtomicIntegerArray sharedVersion
```
    Shared version data structure, for version updates and stale checks
- Constructor Detail
  - BaseRecord
```
protected BaseRecord()
```
    Default constructor which can only be invoked by subclasses. This constructor does not initialize most state-related data structures. If these are needed for legacy record behavior, the initialize(Session, boolean) method should be invoked after construction.
- Method Detail
  - copy
```
public static boolean copy(BaseRecord to,
                           BaseRecord from,
                           boolean b4reserved)
```
    Copy the source record to the destination record.
    The records are checked first to decide whether they are compatible (I.e. the number of properties matches and also the type for each field, including the optional extent attribute). If not, the method returns false and not copy operation is executed.
    If the records pass validation, all properties are copied from source (from) to destination to). At the same time, the status flags are updated so that the destination record can be correctly saved.
    
    Parameters:
    
    to - The destination record.
    
    from - The source record.
    
    b4reserved - If true the before-table specific attributes are copied, too. Otherwise only the normal properties are processed.
    
    Returns:
    
    true if the copy was performed (record's tables match).
  - initialize
```
public void initialize(Session session,
                       boolean setDefaults)
```
    Populate the record's data with its default, initial values and update the record and property states accordingly. Mark the record as newly created.
    This method should be invoked only once, immediately after the object is constructed. It is not invoked directly from the constructor, because the only use case which requires the initialization performed here is a new data record being created on behalf of application logic.
    This is done separately from construction because there are use cases where an instance of this class is needed, but we do not need the overhead of initializing the data with default values, as they will be overwritten anyway. For instance, if the object is read from the database or a copy/snapshot is being made, the data array will be populated with the values retrieved from the database or copied from the other record, respectively.
    It is not invoked optionally from the constructor, because a default constructor called from subclasses is preferable, as the subclasses are often constructed by reflection.
    This operation updates the not-null bitset, based on the values of non-nullable columns.
    
    Parameters:
    
    session - Database session, which is needed if this record must have its changes tracked for UNDO/rollback purposes; otherwise, may be null.
    
    setDefaults - If true, set all default property values; if false, leave data array filled with null values.
  - initialize
```
public void initialize(boolean setDefaults)
```
    Initialize this record instance, by setting all fields to their default values and also initializing the indexState, unvalidated and nullProps states.
    This method should be invoked only once, immediately after the object is constructed. It is not invoked directly from the constructor, because the only use case which requires the initialization performed here is a new data record being created on behalf of application logic.
    This will be used by, JSON deserialization when creating a new record for an instance associated with the web service request (either request or response).
    
    Parameters:
    
    setDefaults - If true, set all default property values; if false, leave data array filled with null values.
  - isInUse
```
public boolean isInUse()
```
    Indicate whether this DMO is "in use"; that is, whether buffers reference it or it is being tracked for UNDO processing.
    
    Returns:
    
    true if in use by the above definition, else false.
  - getIndexState
```
public IndexState getIndexState()
```
    Get the update state of this record's indices.
    
    Returns:
    
    Index state.
  - primaryKey
```
public final java.lang.Long primaryKey()
```
    Get the database identifier for this persistable object. This generally equates to the backing table's primary key. However, it will be null for DMO instances which have not yet been persisted to the database.
    
    Specified by:
    
    primaryKey in interface Persistable
    
    Returns:
    
    Unique, database identifier associated with this object.
  - primaryKey
```
public final void primaryKey(java.lang.Long id)
```
    Set the database identifier for this persistable object (i.e., surrogate primary key).
    
    Specified by:
    
    primaryKey in interface Persistable
    
    Parameters:
    
    id - Unique, database identifier to be associated with this object.
  - deepCopy
```
public BaseRecord deepCopy()
```
    Copy this record's data and record state, including its primary key. The copy MUST NOT find its way into the Session cache.
    
    Returns:
    
    Copy of this record.
  - copy
```
public void copy(BaseRecord from)
```
    Makes this a copy of a source BaseRecord object. For permanent databases, the internal data and the id of the BaseRecord are copied.
    The only state copied is that of which properties are dirty (all of them after the copy). Thus, this method is for specialized, internal use only, such as creating a new record in order to copy data from one temp-table buffer to another.
    
    Parameters:
    
    from - The source to copy data from.
  - checkState
```
public boolean checkState(int flags)
```
    Checks whether a set of record state flags are set for this record.
    
    Parameters:
    
    flags - One or more RecordState flags, bitwise OR'd together.
    
    Returns:
    
    true if ALL flags are set.
    
    See Also:
    
    RecordState
  - isValid
```
public boolean isValid()
```
    Indicate whether the record has passed validation. A newly created and initialized record or a record which has had any of its properties changed is considered invalid, until it passes validation. NOTE: in fact, this is the state the record after the last validation, it might have been changes meanwhile so the state might be staled, check the NEED_VALIDATION bit to see if this is the case and call validation routines
    
    Returns:
    
    true if this record has passed validation and has not since had any of its properties changed, else false.
  - updateState
```
public void updateState(Session session,
                        int flags,
                        boolean set)
```
    Updates the set of state flags for this record. Depending on set parameter, the flags can be set (when true) or removed (when false). If one flag is already set and set == true that flag remains unchanged. The same applies for un-setting an inactive flag.
    
    Parameters:
    
    session - Database session (used for UNDO purposes).
    
    flags - A set of OR-ed RecordState flags to be updated.
    
    set - If true the flags will be set, otherwise they will be unset.
    
    See Also:
    
    RecordState
  - getRecordLockIdentifier
```
public RecordIdentifier<java.lang.String> getRecordLockIdentifier()
```
    Get the unique identifier for this record, comprised of its table name and primary key.
    
    Returns:
    
    Record identifier.
  - isIndexed
```
public boolean isIndexed()
```
    Report whether the table associated with this record has any (legacy) index.
    
    Returns:
    
    true if there is at least one legacy index defined in the table of this record.
  - setActiveBuffer
```
public java.lang.Runnable setActiveBuffer(RecordBuffer buffer)
```
    Set the record buffer which is currently active for this record. This method is called to set the active buffer temporarily associated with this record before some work is done to update this record's data. This may be an update to a single datum or a bulk update.
    A call to this method must be bracketed with a call to run the Runnable returned by this method. This allows nested invocations and ensures that the active buffer and related state are reset properly after the update work is done.
    
    Parameters:
    
    buffer - The buffer which is considered the "active" buffer for a subsequent unit of update work.
    
    Returns:
    
    A Runnable which MUST be executed in a finally block when the update work for which the active buffer was set is finished.
  - restoreActiveState
```
public void restoreActiveState()
```
    Restore to default active buffer, offset, and datum value.
  - isDirty
```
public boolean isDirty()
```
    Indicate whether any property in the record currently is dirty (i.e., touched, not necessarily changed).
    
    Returns:
    
    true if any property was touched, else false.
  - isAnyIndexFullyDirty
```
public boolean isAnyIndexFullyDirty()
```
    Indicate whether all index components for any index on this record are dirty (i.e., have been touched, not necessarily changed..
    
    Returns:
    
    true if any index is fully dirty.
  - undoActive
```
public void undoActive()
```
  - toString
```
public java.lang.String toString()
```
    Return a string representation of this object, primarily for debug purposes.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    String representation of this object.
  - toString
```
public java.lang.String toString(boolean includeData)
```
    Return a string representation of this object, primarily for debug purposes, optionally including the record's data in the output.
    
    Parameters:
    
    includeData - true to include the record's data. If false, all other state still will be included.
    
    Returns:
    
    String representation of this object.
  - getData
```
public java.lang.Object[] getData(PropertyMapper pm)
```
    This accessor allows direct access to private data array only to instances of PropertyMapper. This is needed because the these instances need direct and fast access the data and avoid normal status management of a record when the properties are accessed using the Record's setters and getters. Instances of PropertyMapper are created only when the import is run so that management is not required nor needed.
    
    Parameters:
    
    pm - The PropertyMapper which requests access.
    
    Returns:
    
    The reference to internal data array if the passed parameter is a PropertyMapper
    
    Throws:
    
    java.lang.NullPointerException - If the passed in parameter is null.
  - getData
```
public java.lang.Object[] getData(RecordBuffer rb)
```
    This accessor allows direct access to private data array only to instances of RecordBuffer.
    
    Parameters:
    
    rb - The RecordBuffer which requests access.
    
    Returns:
    
    The reference to internal data array if the passed parameter is a RecordBuffer
    
    Throws:
    
    java.lang.NullPointerException - If the passed in parameter is null.
  - needsValidation
```
public boolean needsValidation()
```
    Indicate whether any of this record's validatable properties are dirty and have not been validated.
    
    Returns:
    
    true if record needs validation, else false.
  - getDirtyIndices
```
public java.util.BitSet getDirtyIndices(int dirtyOffset,
                                        boolean unique,
                                        boolean remaining)
```
    Get a bit set representing dirty unique or non-unique indices, subject to the conditions described by the parameters. A set bit in the returned set indicates a dirty index. The position of each set bit corresponds with the 0-based position of the associated index in the array of unique or non-unique indices for the record.
    
    Parameters:
    
    dirtyOffset - Optional offset of a dirty property which must be a component of the indices returned. If less than 0, all dirty properties are considered. If a non-negative offset is provided, but the corresponding property is not dirty, an empty bit set is returned.
    
    unique - true to return dirty unique indices; false to return dirty non-unique indices.
    
    remaining - If true, only unvalidated indices are returned. Otherwise, validation is not considered.
    
    Returns:
    
    A bit set, as described above. null is returned when no indices are found.
  - getActiveUpdateDiffs
```
public java.lang.Object[] getActiveUpdateDiffs()
```
    Get a two element array representing the old and new values of the property currently being changed. The first element is the previous value of the property; the second is the new value. If the property has not been touched or the old and new values are the same, null is returned.
    Note: this method will only return a non-null result while a property update is active; that is, while a DMO property is being updated via the RecordBuffer invocation handler. It is only at that moment that the previous value for the property being changed is guaranteed to contain meaningful data.
    
    Returns:
    
    See above.
  - getDirtyProps
```
public java.util.BitSet getDirtyProps()
```
    Return the set of bits which are marked dirty. For performance reasons, the object is not copied before being returned. The caller MUST NOT alter its state!
    
    Returns:
    
    Bit set of dirty properties (those that have been touched, not necessarily changed).
  - _getReadFields
```
public java.util.BitSet _getReadFields()
```
    Get the readFields.
    
    Returns:
    
    The readFields.
  - setDatum
```
protected void setDatum(int offset,
                        java.lang.Object datum)
```
    Set a single datum into the data array, and update the record and property state accordingly.
    
    Parameters:
    
    offset - Zero-based offset of the datum in the data array.
    
    datum - Value to be set into the data array.
  - setAllData
```
protected boolean setAllData(BaseRecord source)
```
    Set all data in the data array. This works only if the source has the same structure as the destination (this). A prevalidation should be done - this will only check integrity, type and extents. The order of the matching will be from left to right and it will avoid reserved properties.
    
    Parameters:
    
    source - A record from which the data will be copied to this data array.
    
    Returns:
    
    true if a valid copying could be done; so the properties match in type and extent and the number of properties match (except the reserved ones).
  - getDatum
```
protected java.lang.Object getDatum(int offset)
```
    Get the field's value on the specified offset.
    
    Parameters:
    
    offset - Zero-based offset of the datum in the data array.
    
    Returns:
    
    The field's value.
  - _recordMeta
```
protected abstract RecordMeta _recordMeta()
```
    Get the static record metadata for the concrete subclass.
    
    Returns:
    
    Static record metadata for the subclass.
  - getCodePage
```
protected java.lang.String getCodePage(int offset)
```
    Obtain the codepage of the clob object at position offset.
    Note: in order for this method to work, the activeBuffer must be set in advance. After the method was invoked, it is recommended to clear its value.
    
    Parameters:
    
    offset - The position for clob field.
    
    Returns:
    
    The 4GL name of codepage of the clob field at position offset. If a codepage is not specified or if the field is not a clob, null is returned.
  - checkIncomplete
```
protected void checkIncomplete(int index)
```
    Check if for an incomplete record, the specified field was read or assigned.
    
    Parameters:
    
    index - The field index.
  - markIncomplete
```
void markIncomplete(Session session)
```
    Mark this record as incomplete.
    
    Parameters:
    
    session - Database session (used for UNDO purposes).
  - indexUpdated
```
void indexUpdated(int idxUid)
```
    An index was updated.
    
    Parameters:
    
    idxUid - Index identifier.
  - isAnyIndexFullyDirty
```
boolean isAnyIndexFullyDirty(java.util.BitSet[] indices)
```
    Compare the bitsets in the given array with the bitset of dirty properties for this record and indicate whether all index components for any index in the array are dirty. The positions of the bits correspond with the positions of the properties in the record's data array.
    
    Parameters:
    
    indices - Array of bitsets, where each set bit represents a component of an index.
    
    Returns:
    
    true if all of the components of any index represented in the array are dirty, else false.
  - markValidated
```
void markValidated()
```
    Mark all dirty properties as having been validated.
  - markValidated
```
void markValidated(int bit)
```
    Mark a single property as having been validated.
    
    Parameters:
    
    bit - 0-based index of bit representing the property which has been validated.
  - getUnvalidatedIndices
```
java.util.BitSet getUnvalidatedIndices(int dirtyOffset,
                                       boolean allUnvalidated)
```
    Get a bit set representing the unique indices, if any, which are either fully or partially updated and which have not already been validated. If the record is newly created and has not yet been flushed to the database, a fully updated index is required; otherwise, a partially updated index is sufficient.
    
    Parameters:
    
    dirtyOffset - Optional offset of a dirty property which must be a component of the indices returned. If less than 0, all dirty properties are considered. If a non-negative offset is provided, but the corresponding property is not dirty, an empty bit set is returned.
    
    allUnvalidated - If true, then any unique index containing any property not previously validated is included in the returned bit set. If false, then only indices containing properties that have been explicitly made dirty are included. Setting this to true effectively considers all properties with untouched, default values in the check.
    
    Returns:
    
    A bit set as described above. null is returned if no index is found.
  - getActiveOffset
```
int getActiveOffset()
```
    Get the offset of the property currently being updated, if any. When a DMO's setter method is invoked, the DMO goes into an 'active' state, during which the offset of the property being updated is stored temporarily as the active offset. When the update is complete, no property is considered active.
    The active state may be reset by this method. This should only be done from a Validation object.
    
    Returns:
    
    Non-negative offset of property being updated, or -1 if no offset is currently being updated.
  - clearDirtyState
```
void clearDirtyState(Session session)
              throws PersistenceException
```
    Reset record and property state after database is synchronized with the record's data (i.e., the most recent set of changes have been persisted).
    This method does not turn off the INVALID flag.
    
    Throws:
    
    PersistenceException
  - isPropertyDirty
```
boolean isPropertyDirty(int offset)
```
    Indicate whether the property at the given offset in the DMO's data array is dirty (i.e., has been touched, but not necessarily changed).
    
    Parameters:
    
    offset - Zero-based offset of the target property.
    
    Returns:
    
    true if the property is dirty, else false.
  - getNullProps
```
java.util.BitSet getNullProps()
```
    Get a bit set indicating the positions of data elements which currently are set to null.
    
    Returns:
    
    Null properties bit set.
  - readProperty
```
final int readProperty(int propOffset,
                       java.sql.ResultSet rs,
                       int rsOffset)
                throws PersistenceException
```
    Read a property directly from a ResultSet.
    
    Parameters:
    
    propOffset - The index of the property to be read.
    
    rs - The result set to read from.
    
    rsOffset - The index in ResultSet to read from. If the property is a multiple column then more than one column will ve read from ResultSet.
    
    Returns:
    
    The number of columns actually read from the ResultSet.
    
    Throws:
    
    PersistenceException
  - readProperty
```
final int readProperty(int propOffset,
                       java.sql.ResultSet rs,
                       int rsOffset,
                       boolean skip)
                throws PersistenceException
```
    Read a property directly from a ResultSet.
    
    Parameters:
    
    propOffset - The index of the property to be read.
    
    rs - The result set to read from.
    
    rsOffset - The index in ResultSet to read from. If the property is a multiple column then more than one column will ve read from ResultSet.
    
    skip - Flag indicating if this property will not be read from the result-set.
    
    Returns:
    
    The number of columns actually read from the ResultSet.
    
    Throws:
    
    PersistenceException
  - version
```
void version(java.util.concurrent.atomic.AtomicIntegerArray sharedVersion)
```
    Set this record's version to the canonical, shared version number for this record.
    
    Parameters:
    
    sharedVersion - DMO version information.
  - isStale
```
boolean isStale()
```
    Indicate whether this record's data is stale, based on changes committed by other user contexts.
    Always returns false for temp-table records.
    
    Returns:
    
    true if this record's version does not match the canonical, shared version of the record known to the FWD runtime; false if the versions match or if versioning is disabled for this record.
  - commit
```
void commit()
```
    The current application transaction has been committed. We do not need to maintain a change set any longer. This is only invoked if this record was modified during the transaction, so increment this DMO's version and the shared version.
  - rollback
```
void rollback(int txLevel)
       throws PersistenceException
```
    Perform a full or sub-transaction level rollback of this record to its state as it was immediately before the block of the specified transaction nesting level was entered.
    
    Parameters:
    
    txLevel - The nesting level of sub-transactions of the block being rolled back, where 0 represents the full transaction block, and a positive number represents that number of nested sub-transactions.
    
    Throws:
    
    PersistenceException
  - getDirtyIndices
```
private java.util.BitSet getDirtyIndices(java.util.BitSet[] indices,
                                         int dirtyOffset,
                                         java.util.BitSet filter,
                                         boolean full)
```
    Get a bit set representing dirty unique or non-unique indices, subject to the conditions described by the parameters. A set bit in the returned set indicates a dirty index. The position of each set bit corresponds with the 0-based position of the associated index in the array of unique or non-unique indices for the record.
    
    Parameters:
    
    indices - The array of bit sets representing the indices to be checked. This must be either the set of unique indices or non-unique indices associated with the record. Only one or the other can be checked by a call to this method.
    
    dirtyOffset - Optional offset of a dirty property which must be a component of the indices returned. If less than 0, all dirty properties are considered. If a non-negative offset is provided, but the corresponding property is not dirty, an empty bit set is returned.
    
    filter - An inclusive filter to apply to the results. If non-empty, each bit in the filter's bit set represents the position of an index to be checked in the indices parameter. If empty, the returned bit set will be empty.
    
    full - If true, ALL index components must be dirty for an index to be considered dirty. If false, one or more index components must be dirty for an index to be considered dirty.
    
    Returns:
    
    A bit set, as described above. null is returned when no indices are found.
  - dataChanged
```
private void dataChanged(int offset,
                         java.lang.Object datum)
                  throws PersistenceException
```
    A property's value has changed. Update the record's internal state accordingly and set up rollback information if the record is undoable.
    
    Parameters:
    
    offset - The datum's offset in the record's data array.
    
    datum - The new value of the datum (may be null).
    
    Throws:
    
    PersistenceException
  - bulkDataChanged
```
private void bulkDataChanged(java.util.List<java.lang.Integer> offsets,
                             java.util.List<java.lang.Object> datums)
                      throws PersistenceException
```
    Multiple property values have changed. Update the record's internal state accordingly and set up rollback information if the record is undoable.
    
    Parameters:
    
    offsets - A list of offsets for the changed values in record's data array.
    
    datums - A list of new values for the changed datums.
    
    Throws:
    
    PersistenceException
  - updateState
```
private void updateState(int flags,
                         boolean set)
```
    Updates the set of state flags for this record. Depending on add parameter, the flags can be set (when true) or removed (when false. If one flag is already set and add == true that flag remains unchanged. The same stands for un-setting a not active flag.
    
    Parameters:
    
    flags - A set of OR-ed RecordState flags to be updated.
    
    set - If true the flags will be set, otherwise they will be unset.
    
    See Also:
    
    RecordState
  - prepareChangeSet
```
private int prepareChangeSet(Session session)
                      throws PersistenceException
```
    If this is the first update to this record since an application transaction began, prepare a change set to track updates made to the record during the transaction, to be used for full or sub-transaction rollback, if needed.
    For a change set to be prepared, the following conditions must be met:
    - a record buffer must be associated with the record, indicating that this call is being made in the context of a business logic call into the record;
    - the record must be associated with an undoable table;
    - an application-level transaction must currently be active.
    If a change set for the current transaction already exists, another is not created.
    A non-negative return value indicates a change set exists and is ready to track changes.
    Parameters:
    
    session - Database session to be interrogated for transaction information.
    
    Returns:
    
    The current transaction nesting level, or -1 if any of the above conditions are not met.
    
    Throws:
    
    PersistenceException
  - lockForUpdate
```
private boolean lockForUpdate()
```
    Obtain an exclusive lock for the current record on behalf of the active buffer, if any.
    
    Returns:
    
    true if the lock is successfully obtained, or if it is unneeded due to system state, or if there is no active buffer. false if there was an error obtaining the lock (and we are in silent error mode).
  - getTable
```
private java.lang.String getTable()
```
    Get the name of the primary table associated with this record.
    
    Returns:
    
    Primary table name.
  - getSize
```
public long getSize()
```
    Get the size of the record.
    
    Returns:
    
    Size of the record in bytes.

Class BaseRecord

Field Summary

Fields inherited from interface com.goldencode.p2j.persist.orm.DmoState

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

PK_GETTER

id

data

readFields

state

references

dirtyProps

unvalidated

nullProps

indexState

recid

activeBuffer

activeOffset

activePropPreviousValue

changeSet

version

sharedVersion

Constructor Detail

BaseRecord

Method Detail

copy

initialize

initialize

isInUse

getIndexState

primaryKey

primaryKey

deepCopy

copy

checkState

isValid

updateState

getRecordLockIdentifier

isIndexed

setActiveBuffer

restoreActiveState

isDirty

isAnyIndexFullyDirty

undoActive

toString

toString

getData

getData

needsValidation

getDirtyIndices

getActiveUpdateDiffs

getDirtyProps

_getReadFields

setDatum

setAllData

getDatum

_recordMeta

getCodePage

checkIncomplete

markIncomplete

indexUpdated

isAnyIndexFullyDirty

markValidated

markValidated

getUnvalidatedIndices

getActiveOffset

clearDirtyState

isPropertyDirty

getNullProps

readProperty

readProperty

version

isStale

commit

rollback

getDirtyIndices

dataChanged