Class HeapPostCommit

  • All Implemented Interfaces:
    Serviceable

    class HeapPostCommit
    extends java.lang.Object
    implements Serviceable
    The HeapPostCommit class implements the Serviceable protocol. In it's role as a Serviceable object, it stores the state necessary to find a page in a heap that may have committed delete's to reclaim. It looks up the page described, and reclaims space in the conglomerate. It first trys to clean up any deleted commits on the page. It will then deallocate the page if no rows remain on the page. All work is done while holding the latch on the page, and locks are never "waited" on while holding this latch. This implementation uses record level locking to reclaim the space. For the protocols to work correctly all other heap methods must be prepared for a record or a page to "disappear" if they don't hold a latch and/or a lock. An example of the problem case is a scan which does not hold locks on it's current position (group scan works this way), which is positioned on a row deleted by another xact, it must be prepared to continue the scan after getting an error if the current page/row disapppears.
    • Field Detail

      • access_factory

        private AccessFactory access_factory
        Fields of the class
      • page_key

        private PageKey page_key
    • Constructor Detail

      • HeapPostCommit

        HeapPostCommit​(AccessFactory access_factory,
                       PageKey page_key)
        Constructors for This class:
    • Method Detail

      • purgeCommittedDeletes

        private final void purgeCommittedDeletes​(HeapController heap_control,
                                                 long pageno)
                                          throws StandardException
        Reclaim space taken of committed deleted rows or aborted inserted rows.

        This routine assumes it has been called by an internal transaction which has performed no work so far, and that it has an exclusive intent table lock. It will attempt obtain exclusive row locks on rows marked deleted, where successful those rows can be reclaimed as they must be "committed deleted" or "aborted inserted" rows.

        This routine will latch the page and hold the latch due to interface requirement from Page.purgeAtSlot.

        Parameters:
        heap_control - The heap, already opened.
        pageno - number of page to look for committed deletes.
        Throws:
        StandardException - Standard exception policy.
        See Also:
        Page.purgeAtSlot(int, int, boolean)
      • serviceASAP

        public boolean serviceASAP()
        The urgency of this post commit work.

        This determines where this Serviceable is put in the post commit queue. Post commit work in the heap can be safely delayed until there is not user work to do.

        Specified by:
        serviceASAP in interface Serviceable
        Returns:
        false, this work should not be serviced ASAP
      • serviceImmediately

        public boolean serviceImmediately()
        Description copied from interface: Serviceable
        If this work should be done immediately on the user thread then return true. If it doesn't make any difference if this work is done on a the user thread immediately or if it is performed by another thread asynchronously later, then return false.
        Specified by:
        serviceImmediately in interface Serviceable
      • performWork

        public int performWork​(ContextManager contextMgr)
                        throws StandardException
        perform the work described in the postcommit work.

        In this implementation the only work that can be executed by this post commit processor is this class itself.

        Specified by:
        performWork in interface Serviceable
        Parameters:
        contextMgr - the context manager started by the post commit daemon
        Returns:
        Returns Serviceable.DONE when work has completed, or returns Serviceable.REQUEUE if work needs to be requeued.
        Throws:
        StandardException - Standard exception policy.