Home >> All >> org >> apache >> derby >> impl >> store >> raw >> [ data Javadoc ]

• org.apache.derby.impl.store.raw.data: Javadoc index of package org.apache.derby.impl.store.raw.data.


Package Samples:

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

Classes:

• ReclaimSpaceHelper: This class helps a BaseDataFactory reclaims unused space. Space needs to be reclaimed in the following cases: Row with long columns or overflow row pieces is deleted Insertion of a row that has long columns or overflows to other row pieces is rolled back Row is updated and the head row or some row pieces shrunk Row is updated and some long columns are orphaned because they are updated Row is updated and some long columns are created but the update rolled back Row is updated and some new row pieces are created but the update rolled back We can implement a lot of optimization if we know that btree ...
• StoredFieldHeader: A class to provide static methods to manipulate fields in the field header. A class StoredPage uses to read/write field status and field data length. No attributes exist in this class, this class provides a set of static methods for writing field status and field data length, and for reading field status and field data length. Stored Field Header Format The field header is broken into two sections. Only the Status byte is required to be there. Field header format: +--------+-------------------+ | status | | +--------+-------------------+ Overflow page and overflow id are stored as field data. If ...
• AllocPage: An allocation page of the file container. This class extends a normal Stored page, with the exception that a hunk of space may be 'borrowed' by the file container to store the file header. The borrowed space is not visible to the alloc page even though it is present in the page data array. It is accessed directly by the FileContainer. Any change made to the borrowed space is not managed or seen by the allocation page. Page Format An allocation page extends a stored page, the on disk format is different from a stored page in that N bytes are 'borrowed' by the container and the page header of an ...
• ContainerOperation: Log operation to create, drop or remove a container. Both the doMe or the undoMe of a create actually caused the container header to be modified and flushed before the log record is flushed. This is necessary for 2 reasons, one is that of ensuring enough disk space, and the other is because unlike any other operation, the log record create container is in the log stream before the container is in the container cache. What this mean is that if a checkpoint started after the container operation but before the container is kept or is dirtied in the container cache, then checkpoint will not know to ...
• AllocationCache: An auxiliary object to cache the allocation information for a file container. Only a FileContainer should use this object The allocation cache contains an array of AllocExtents and 3 arrays of longs: ExtentPageNums[i] is the page number of the i'th extent lowRange[i] is the smallest page number managed by extent i hiRange[i] is the largest page number managed by extent i Note thate extentPageNums and lowRange does not change once the extent has been created, but hiRange will change for the last extent as more pages are allocated. Extents can be individually invalidated or the entire cache (all ...
• BaseDataFileFactory: Provides the abstract class with most of the implementation of DataFactory and ModuleControl shared by all the different filesystem implementations. RESOLVE (mikem - 2/19/98) - Currently only getContainerClass() is abstract, there are probably more routines which should be abstract. Also the other implementations should probably inherit from the abstract class, rather than from the DataFileFactory class. Also there probably should be a generic directory and the rest of the filesystem implementations parallel to it. I wanted to limit the changes going into the branch and then fix inheritance stuff ...
• StoredRecordHeader: A class StoredPage uses to cache record headers by passing instances to BasePage, and to write stored versions of record headers. Format 1 byte - status compressed int - record identifier compressed long - overflow page } only if hasOverflow() is true compressed int - overflow id } " " " compressed int - first field } only if hasFirstField set - otherwise 0 compressed int - number of fields in this portion - only if hasOverflow() is false OR hasFirstField is true - otherwise 0
• PageBasicOperation: 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.
• BasePage: This class implements all the the generic locking behaviour for a Page. It leaves method used to log and store the records up to sub-classes. It is intended that the object can represent multiple pages from different containers during its lifetime. A page contains a set of records, which can be accessed by "slot", which defines the order of the records on the page, or by "id" which defines the identity of the records on the page. Clients access records by both slot and id, depending on their needs. BasePage implements Observer to watch the ContainerHandle which notifies its Observers when it is ...
• PhysicalPageOperation: An abstract class that is used for physical log operation. A physical log operation is one where the undo of the operation must be applied to the same page as the original operation, and the undo operation must store the byte image of the row(s) changed to its before image. (If a logical page operation happened to the page or if another transaction altered other rows on the page, the undo of this operation will only restore the before image of the row(s) affected).
• BaseContainer: BaseContainer is an abstract class that provides the locking bahaviour for an object representing an active container, that is the actual storage container, not the ContainerHandle interface. This class is designed so that it can change the container it represents to avoid creating a new object for every container. This object implements lockable to provide an object to lock while a page is being allocated. MT - Mutable - mutable identity :
• StreamFileContainer: The format of this stream file is: (RH) (FH) (field data) (FH) (field data) ........ (FH) (field data) Record header is stored once at the beginning of the file for all the rows stored in this file. Record Header indicates how many fields are in each row. Then we just stored all the column from each row. Field header stored on this file is fixed size with fieldDataLength size set to LARGE_SLOT_SIZE (4) bytes. NOTE: No locks are used in this container. All transaction are not logged.
• RememberBytesInputStream: A FilterInputStream that remembers read or skipped bytes. In record mode this stream remembers all the bytes a caller reads or skips. After reading some bytes this returns a 'replay' stream to re-read them. A caller may call getReplaySteam to get a stream to re-read the the remembered bytes. Any number of calls to getReplayStream are supported. The clear function causes this stream to forget the remembered bytes and re-enter record mode.
• BaseContainerHandle: A handle to an open container, implememts RawContainerHandle. This class is an Observer to observe RawTransactions and is also a Observable to handle the list of pages accessed thorough this handle. This class implements Lockable (defined to be ContainerHandle) and is the object used to logically lock the container. MT - Mutable - Immutable identity - Thread Aware
• RecordId: Implementation of RecordHandle. MT - Mutable - Immutable identity : Thread Aware - The methods of RecordHandle only access the identity of the object and so the object appears immutable to them, as required. The methods of Lockable are single thread required.
• TempRAFContainer: needsSync is never true - DONE An exception never marks the store as corrupt clean() does not stubbify preAllocate() does nothing - DONE getFileName() returns a file in the tmp directory - DONE flushAll does nothing - DONE file descriptor is never synced
• AllocationActions: This interface describe the operations that has to do with page allocation/deallocation. This interface is used for a special allocation page that records the allocation information and dispense the allocation policy.
• ByteHolder: Holder for a growing sequence of bytes. The ByteHolder supports a writing phase in which a caller appends bytes to the ByteHolder. Later the caller may read the bytes out of the ByteHolder in the order they were written.
• LogicalUndoOperation: LogicalUndoOperation is a compensation operation that rolls back the change of an LogicalUndoable operation. A LogicalUndoOperation itself is not undo-able, i.e, it is loggable but not undoable.
• AllocExtent: An allocation extent row manages the page status of page in the extent. AllocExtent is externalizable and is written to the AllocPage directly, without being converted to a row first.
• D_StoredPage: The D_StoredPage class provides diagnostic information about the StoredPage class. Currently this info includes: o a dump of the page. o page size of the page. o bytes free on the page. o bytes reserved on the page.
• PhysicalUndoOperation: PhysicalUndoOperation is a compensation operation that rolls back the change of an Undo-able operation. A PhysicalUndoOperation itself is not undo-able, i.e, it is loggable but not undoable.
• LogicalPageOperation: 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.
• InvalidatePageOperation: Represents invalidating a page due to deallocation. This operation invalidates the page that is being deallocated, as opposed to deallocatePage that happens on the alloc page.
• StreamFileContainerHandle: A handle to an open stream container, implememts StreamContainerHandle. This class is an Observer to observe RawTransactions MT - Mutable - Immutable identity - Thread Aware

Home | Contact Us | Privacy Policy | Terms of Service