Class PageBasicOperation

java.lang.Object

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

All Implemented Interfaces:

Externalizable, Serializable, Formatable, TypedFormat, Loggable, RePreparable

Direct Known Subclasses:

LogicalPageOperation, LogicalUndoOperation, PhysicalPageOperation, PhysicalUndoOperation, SetReservedSpaceOperation

abstract class PageBasicOperation
extends Object
implements Loggable, RePreparable

A PageBasicOperation changed the content of a page, this is the root class of all page oriented operation. Each PageBasicOperation record change(s) that apply to one and only one page. The pageID that is changed must be recorded in the log operation - in other words, redo must be physical (or more correctly, in Gray's term, physiological, since changes are logical within a page).
Undo can be logical, but the undo logic must be hidden in generateUndo. By the time a compensation operation is logged as a LogOperation, the page that needs roll back must be determined.

See Also:

• Loggable

Field Summary

Fields

Modifier and Type	Field	Description
protected RawContainerHandle	containerHdl
protected boolean	foundHere
protected BasePage	page
private PageKey	pageId
private long	pageVersion

Fields inherited from interface Loggable

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

Constructor Summary

Constructors

Constructor	Description
PageBasicOperation()
PageBasicOperation(BasePage page)

Method Summary

Modifier and Type	Method	Description
final BasePage	findpage(Transaction xact)	Find the page the operation applies to and latch it, this only uses the segmentId, containerId, and pageId stored in this log record to find the page.
final Page	getPage()
protected BasePage	getPageForRedoRecovery(Transaction xact)	Subclass (e.g., init page) that wishes to do something about missing pages in load tran should override this method to return the page
protected final PageKey	getPageId()
final long	getPageVersion()
ByteArray	getPreparedLog()	the default for optional data is set to null.
int	group()	A page operation is a RAWSTORE log record
final boolean	needsRedo(Transaction xact)	Returns true if this op should be redone during recovery redo, if so, get and latched the page.
void	readExternal(ObjectInput in)
void	reclaimPrepareLocks(Transaction t, LockingPolicy locking_policy)	reclaim locks associated with the changes in this log record.
void	releaseResource(Transaction xact)	Release latched page and any other resources acquired during a previous findpage, safe to call multiple times.
protected final void	resetPageNumber(long pageNumber)	Reset the pageNumber
abstract void	restoreMe(Transaction xact, BasePage undoPage, LogInstant CLRinstant, LimitObjectInput in)	Undo the change indicated by this log operation and optional data.
String	toString()
void	writeExternal(ObjectOutput out)

Methods inherited from class Object

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

Methods inherited from interface Loggable

doMe

Methods inherited from interface TypedFormat

getTypeFormatId

Field Details

pageId

private PageKey pageId

pageVersion

private long pageVersion

page

protected transient BasePage page

containerHdl

protected transient RawContainerHandle containerHdl

foundHere

protected transient boolean foundHere

Constructor Details

PageBasicOperation

PageBasicOperation(BasePage page)

PageBasicOperation

PageBasicOperation()

Method Details

toString

public String toString()

Overrides:

toString in class Object

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:

writeExternal in interface Externalizable

Throws:

IOException

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
ClassNotFoundException

Specified by:

readExternal in interface Externalizable

Throws:

IOException

ClassNotFoundException

needsRedo

public final boolean needsRedo(Transaction xact)
                        throws StandardException

Returns true if this op should be redone during recovery redo, if so, get and latched the page.

Specified by:

needsRedo in interface Loggable

Parameters:

xact - The transaction trying to redo this operation

Returns:

true if operation needs redoing, false if not.

Throws:

StandardException - Standard Derby policy.

See Also:

• Loggable.releaseResource(Transaction)

releaseResource

public void releaseResource(Transaction xact)

Release latched page and any other resources acquired during a previous findpage, safe to call multiple times. In this RawStore implementataion, resource is acquired by a log operation in one of two places

during runtime or recovery undo in PageOperation.generateUndo()

during recovery redo in PageBasicOperation.needsRedo()

Specified by:

releaseResource in interface Loggable

group

public int group()

A page operation is a RAWSTORE log record

Specified by:

group in interface Loggable

getPreparedLog

public ByteArray getPreparedLog()
                         throws StandardException

the default for optional data is set to null. If an operation has optional data, the operation need to prepare the optional data for this method. WARNING: If a log operation extends this class, and the operation has optional data, it MUST overwrite this method to return a ByteArray that contains the optional data.

Specified by:

getPreparedLog in interface Loggable

Throws:

StandardException - Standard Derby policy.

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

Throws:

StandardException - Standard exception policy.

resetPageNumber

protected final void resetPageNumber(long pageNumber)

Reset the pageNumber

getPageId

protected final PageKey getPageId()

findpage

public final BasePage findpage(Transaction xact)
                        throws StandardException

Find the page the operation applies to and latch it, this only uses the segmentId, containerId, and pageId stored in this log record to find the page.

Returns:

null if container is dropped and committed (possibly stubbified), else return the latched page

Throws:

StandardException - Standard Derby policy.

getPageForRedoRecovery

protected BasePage getPageForRedoRecovery(Transaction xact)
                                   throws StandardException

Subclass (e.g., init page) that wishes to do something about missing pages in load tran should override this method to return the page

Throws:

StandardException - Derby Standard error policy

getPage

public final Page getPage()

getPageVersion

public final long getPageVersion()

restoreMe

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

Undo the change indicated by this log operation and optional data. The page the undo should apply to is the latched undoPage. The undoPage must be the same page as the doMe page and the undo operation must restore the before image of the row that changed.
this can only be used under special circumstances: namely table level locking, and no internal or nested transaction, and all operations are rollec back with restoreMe instead of undoMe.
This method is here to support BeforeImageLogging

Parameters:

xact - the Transaction doing the rollback

undoPage - the page 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.