| org.apache.derby.iapi.store.raw.Loggable
All known Subclasses: org.apache.derby.impl.store.raw.log.ChecksumOperation, org.apache.derby.impl.store.raw.log.CheckpointOperation, org.apache.derby.impl.store.raw.data.ContainerBasicOperation, org.apache.derby.impl.store.raw.data.PageBasicOperation, org.apache.derby.impl.store.raw.xact.BeginXact, org.apache.derby.impl.store.raw.xact.EndXact,
| Loggable | | public interface Loggable extends Formatable(Code) | | A Loggable is a record of a change of state or an event that happened
in the RawStore in the context of a transaction.
All changes in the RawStore must be logged.
This is the root class for all log operations.
See Also: Transaction.logAndDo |
| Field Summary | |
| final public static int | ABORT
| | final public static int | BI_LOG
| | final public static int | CHECKSUM
| | final public static int | COMMIT
| | final public static int | COMPENSATION
| | final public static int | FILE_RESOURCE
| | final public static int | FIRST
Each loggable belongs to one or more groups of similar functionality.
Grouping is a way to quickly sort out log records that are interesting
to different modules or different implementations.
When a module makes loggable and sent it to the log file, it must mark
this loggable with one or more of the following group. | | final public static int | LAST
| | final public static int | PREPARE
| | final public static int | RAWSTORE
| | final public static int | XA_NEEDLOCK
|
| Method Summary | |
| public void | doMe(Transaction xact, LogInstant instant, LimitObjectInput in)
Apply the change indicated by this operation and optional data.
If this method fail, the system will be shut down because the log
record has already been written to disk. | | public ByteArray | getPreparedLog()
The log operations are responsible to create the ByteArray, and the log
operations should write out any optional data for the change to the
ByteArray. | | public int | group()
| | public boolean | needsRedo(Transaction xact)
Determine if the operation should be reapplied in recovery redo.
If redo is needed, acquire any resource that is necessary for the
loggable's doMe method. | | public void | releaseResource(Transaction xact)
Release any resource that was acquired for doMe for rollback or
recovery redo.
This resource is acquired in either generateUndo (if this is a
compensation operation during run time rollback or recovery rollback)
or in needsRedo (if this is during recovery redo). |
| ABORT | | final public static int ABORT(Code) | | |
| BI_LOG | | final public static int BI_LOG(Code) | | |
| CHECKSUM | | final public static int CHECKSUM(Code) | | |
| COMMIT | | final public static int COMMIT(Code) | | |
| COMPENSATION | | final public static int COMPENSATION(Code) | | |
| FILE_RESOURCE | | final public static int FILE_RESOURCE(Code) | | |
| FIRST | | final public static int FIRST(Code) | | Each loggable belongs to one or more groups of similar functionality.
Grouping is a way to quickly sort out log records that are interesting
to different modules or different implementations.
When a module makes loggable and sent it to the log file, it must mark
this loggable with one or more of the following group.
If none fit, or if the loggable encompasses functionality that is not
described in existing groups, then a new group should be introduced.
Grouping has no effect on how the record is logged or how it is treated
in rollback or recovery.
The following groups are defined. This list serves as the registry of
all loggable groups.
|
| LAST | | final public static int LAST(Code) | | |
| PREPARE | | final public static int PREPARE(Code) | | |
| RAWSTORE | | final public static int RAWSTORE(Code) | | |
| XA_NEEDLOCK | | final public static int XA_NEEDLOCK(Code) | | |
| doMe | | public void doMe(Transaction xact, LogInstant instant, LimitObjectInput in) throws StandardException, IOException(Code) | | Apply the change indicated by this operation and optional data.
If this method fail, the system will be shut down because the log
record has already been written to disk. Moreover, the log record will
be replayed during recovery and this doMe method will be called on the
same page again, so if it fails again, recovery will fail and the
database cannot be started. So it is very important to make sure that
every resource you need, such as disk space, has been acquired before
the logAndDo method is called!
This method cannot acquire any resource (like latching of a page)
since it is called underneath the logging system, ie., the log record has
already been written to the log stream.
The available() method of in indicates how much data can be read, i.e.
how much was originally written.
Parameters:
xact - the Transaction
Parameters:
instant - the log instant of this operation
Parameters:
in - optional data
exception:
IOException - Can be thrown by any of the methods of in.
exception:
StandardException - Standard Cloudscape policy. |
| getPreparedLog | | public ByteArray getPreparedLog() throws StandardException(Code) | | The log operations are responsible to create the ByteArray, and the log
operations should write out any optional data for the change to the
ByteArray.
The ByteArray can be prepared when the log operation is constructed,
or it can be prepared when getPreparedLog() is called.
Called by the log manager to allow the log operation to pass the buffer
which contains optional data that will be available in to doMe()
methods.
exception:
StandardException - Standard Cloudscape policy. |
| group | | public int group()(Code) | | Get the loggable's group value
|
| needsRedo | | public boolean needsRedo(Transaction xact) throws StandardException(Code) | | Determine if the operation should be reapplied in recovery redo.
If redo is needed, acquire any resource that is necessary for the
loggable's doMe method. These need to be released in the
releaseResource method.
The sequence of events in recovery redo of a Loggable operation is:
Get the loggable operation. If loggable.needsRedo is false, then
no need to redo this operation.
If loggable.needsRedo is true, all the resources necessary for
applying the doMe is acquired in needsRedo.
If the loggable is actually a compensation operation, then the
logging system will find the undoable operation that needs to be
undone, call compensation.setUndoOp with the undoable operation.
The recovery system then calls loggable.doMe, which re-applies the
loggable operation, or re-applies the compensation operation
The recovery system then calls loggable.releaseResource.
Parameters:
xact - The transaction trying to redo this operation true if operation needs redoing, false if not.
exception:
StandardException - Standard Cloudscape policy.
See Also: Loggable.releaseResource |
| releaseResource | | public void releaseResource(Transaction xact)(Code) | | Release any resource that was acquired for doMe for rollback or
recovery redo.
This resource is acquired in either generateUndo (if this is a
compensation operation during run time rollback or recovery rollback)
or in needsRedo (if this is during recovery redo). The run time
transaction context should have all the resource already acquird for
run time roll forward, so there is no need to releaseResource during
run time roll forward.
This method must be safe to be called multiple times.
|
|
|