Class LogicalPageOperation

java.lang.Object

org.apache.derby.impl.store.raw.data.PageBasicOperation

org.apache.derby.impl.store.raw.data.LogicalPageOperation

All Implemented Interfaces:

Externalizable, Serializable, Formatable, TypedFormat, Loggable, LogicalUndoable, RePreparable, Undoable

Direct Known Subclasses:

DeleteOperation, InsertOperation, UpdateFieldOperation

abstract class LogicalPageOperation
extends PageBasicOperation
implements LogicalUndoable

An abstract class that is used for logical log operation. A logical log operation is one where the undo of the operation may be applied to a different page than the original operation.

Field Summary

Fields

Modifier and Type	Field	Description
protected int	recordId
protected LogicalUndo	undo

Fields inherited from class PageBasicOperation

containerHdl, foundHere, page

Fields inherited from interface Loggable

ABORT, BI_LOG, CHECKSUM, COMMIT, COMPENSATION, FILE_RESOURCE, FIRST, LAST, PREPARE, RAWSTORE, XA_NEEDLOCK

Constructor Summary

Constructors

Constructor	Description
LogicalPageOperation()
LogicalPageOperation(BasePage page, LogicalUndo undo, int recordId)

Method Summary

Modifier and Type	Method	Description
private BasePage	findLogicalPage(Transaction xact, LogicalUndo undo, LimitObjectInput in)	Find the page that the rollback operation should be applied to.
Compensation	generateUndo(Transaction xact, LimitObjectInput in)	Generate a Compensation (PageUndoOperation) that will rollback the changes of this page operation.
ContainerHandle	getContainer()	Return the container handle where the log operated on
RecordHandle	getRecordHandle()	Return the record handle that correspond to the record that was changed during roll forward.
void	readExternal(ObjectInput in)	Read this in
void	reclaimPrepareLocks(Transaction t, LockingPolicy locking_policy)	reclaim locks associated with the changes in this log record.
void	resetRecordHandle(RecordHandle rh)	After the logical undo logic figures out where the real record that needs roll back is, reset this log operation to refer to that record
abstract void	undoMe(Transaction xact, BasePage undoPage, int undoRecordId, LogInstant CLRinstant, LimitObjectInput in)	Undo the change indicated by this log operation and optional data.
void	writeExternal(ObjectOutput out)

Methods inherited from class PageBasicOperation

findpage, getPage, getPageForRedoRecovery, getPageId, getPageVersion, getPreparedLog, group, needsRedo, releaseResource, resetPageNumber, restoreMe, toString

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface Loggable

doMe, getPreparedLog, group, needsRedo, releaseResource

Methods inherited from interface LogicalUndoable

restoreLoggedRow

Methods inherited from interface TypedFormat

getTypeFormatId

Field Details

undo

protected LogicalUndo undo

recordId

protected int recordId

Constructor Details

LogicalPageOperation

public LogicalPageOperation()

LogicalPageOperation

LogicalPageOperation(BasePage page,
 LogicalUndo undo,
 int recordId)

Method Details

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:

writeExternal in interface Externalizable

Overrides:

writeExternal in class PageBasicOperation

Throws:

IOException

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
ClassNotFoundException

Read this in

Specified by:

readExternal in interface Externalizable

Overrides:

readExternal in class PageBasicOperation

Throws:

IOException - error reading from log stream

ClassNotFoundException - log stream corrupted

generateUndo

public Compensation generateUndo(Transaction xact,
 LimitObjectInput in)
                          throws StandardException,
IOException

Generate a Compensation (PageUndoOperation) that will rollback the changes of this page operation. If this Page operation cannot or need not be rolled back (redo only), overwrite this function to return null.

Specified by:

generateUndo in interface Undoable

Parameters:

xact - the transaction doing the rollback

Returns:

the compensation operation that will rollback this change, or null if nothing to undo.

Throws:

StandardException - Standard Derby policy.

IOException - Method may read from ObjectInput

See Also:

• LogicalUndo

getContainer

public ContainerHandle getContainer()

Return the container handle where the log operated on

Specified by:

getContainer in interface LogicalUndoable

resetRecordHandle

public void resetRecordHandle(RecordHandle rh)

After the logical undo logic figures out where the real record that needs roll back is, reset this log operation to refer to that record

Specified by:

resetRecordHandle in interface LogicalUndoable

Parameters:

rh - the RecordHandle that represents the row's new location

getRecordHandle

public RecordHandle getRecordHandle()

Return the record handle that correspond to the record that was changed during roll forward. This is used as a hint by logical undo as a good place to look for the record to apply the roll back.

Specified by:

getRecordHandle in interface LogicalUndoable

reclaimPrepareLocks

public void reclaimPrepareLocks(Transaction t,
 LockingPolicy locking_policy)
                         throws StandardException

reclaim locks associated with the changes in this log record.

Specified by:

reclaimPrepareLocks in interface RePreparable

Overrides:

reclaimPrepareLocks in class PageBasicOperation

Parameters:

locking_policy - The locking policy to use to claim the locks.

Throws:

StandardException - Standard exception policy.

findLogicalPage

private BasePage findLogicalPage(Transaction xact,
 LogicalUndo undo,
 LimitObjectInput in)
                          throws StandardException,
IOException

Find the page that the rollback operation should be applied to.

The actual logical log operation is expected to implement Undoable.generateUndo. This utility function findLogicalPage is provided for the common case scenario of using a LogicalUndo interface to find the undo page. The subclass that implements Undoable.generateUndo can use this function to find the logical page with its LogicalUndo callback function. This method can be used with the default releaseResource().

During recovery redo, the logging system is page oriented and will use the pageID stored in the PageUndoOperation to find the page. The page will be latched and released using the default findpage and releaseResource - this.releaseResource() will still be called so it has to know not to release any resource it did not acquire.

Parameters:

xact - the transaction doing the compensating

in - optional input

Returns:

the compensation operation that will rollback this change

Throws:

StandardException - Standard Derby error policy

IOException - Method may read from ObjectInput

See Also:

• PageBasicOperation
• Undoable.generateUndo(Transaction, LimitObjectInput)
• Loggable.releaseResource(Transaction)

undoMe

public abstract void undoMe(Transaction xact,
 BasePage undoPage,
 int undoRecordId,
 LogInstant CLRinstant,
 LimitObjectInput in)
                     throws StandardException,
IOException

Undo the change indicated by this log operation and optional data. The undoPage and undoRecordId is the page, record the undo should apply to. The undoRecorId differs from the roll forward recordId if the undoPage differs from the page the roll forward operation was applied to, in other words, the record moved to another page and the recordId changed.
A logical operation can at most deal with 1 record.

The available() method of in indicates how much data can be read, i.e. how much was originally written.
In this RawStore implementation, should only only be called via CompOp.doMe.

Parameters:

xact - the Transaction doing the rollback

undoPage - the page to rollback changes on

undoRecordId - the recordId to rollback changes on

CLRinstant - the log instant of this (PageUndo) operation

in - optional data for the rollback operation

Throws:

IOException - Can be thrown by any of the methods of ObjectInput.

StandardException - Standard Derby policy.