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:
  • 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:
    • 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.