Package com.persistit

Implements Persistit™'s core functionality.

See: Description

Interface Summary

Interface	Description
Exchange.TraverseVisitor	A visitor used with the Exchange.traverse(Key.Direction, boolean, int, TraverseVisitor) The Exchange.TraverseVisitor.visit(ReadOnlyExchange) method is called once for each Key traversed by the traverse method.
Management	Interface for a service object that exposes information about the Persistit environment.
Management.DisplayFilter	A DisplayFilter formats the String value presented in the Tree tab of the AdminUI.
ReadOnlyExchange	Methods of the Exchange class that are safe to use within a Exchange.TraverseVisitor.
TransactionRunnable	Interface for objects that perform Persistit™ operations within the scope of a Transaction.

Class Summary

Class	Description
Accumulator	An Accumulator accumulates statistical information in the MVCC Transaction environment without creating write-write dependency conflicts.
Accumulator.MaxAccumulator	An Accumulator that computes a maximum value
Accumulator.MinAccumulator	An Accumulator that computes a minimum value
Accumulator.SeqAccumulator	An Accumulator used to generate unique ID values.
Accumulator.SumAccumulator	An Accumulator that computes a sum
AlertMonitor	Manage the process of accumulating and logging abnormal events such as IOExceptions and measurements outside of expected thresholds.
AlertMonitor.AlertRecord
AlertMonitor.Event	Holder for event data including the event arguments and the time the event was posted.
BackupTask	Task to perform and/or control hot (concurrent) backup.
Buffer	Memory structure that holds and manipulates the state of a fixed-length page of a Volume.
BufferPool	A pool of Buffer objects, maintained on various lists that permit rapid lookup and replacement of pages images within Buffers.
CLI	Handle commands delivered interactively as command strings.
Configuration	Configuration parameters used to determine locations of files, sizes of buffer pool and journal allocation, policies and other parameters required during Persistit initialization.
Configuration.BufferPoolConfiguration	Configuration constraints that determine the number of Buffers in a BufferPool.
DefaultCoderManager	A simple CoderManager implementation that associates each registered Class with its corresponding KeyCoder or ValueCoder.
DefaultObjectCoder	An ObjectCoder that uses reflection to access the properties and/or fields of an object.
DefaultValueCoder	A ValueCoder that uses reflection to access and modify the fields of an object.
DefaultValueCoder.Builder	A component of a DefaultValueCoder that reads and writes data values to and from properties or fields of a client object.
Exchange	The main facade for fetching, storing and removing records from a Persistit™ database.
GetVersion	Access the build version string from a resource included in the persistit jar file.
IntegrityCheck	A simple integrity checker that traverses all pages within one or more Trees, verifies the internal structure of each page, and verifies the relationships between the pages.
IntegrityCheck.Fault	A representation of an error or inconsistency within a Tree.
JournalManagerBench	Benchmark for primitive I/O simulating HARD (durable) commit.
JournalRecord	This class encapsulates the formats of Persistit journal records.
Key	Encapsulates the key used in storing, fetching or deleting a key/value pair from a Persistit™ database.
Key.EdgeValue	Enumeration of special key segment values used to traverse from the first or last key.
KeyFilter	Specifies a subset of all possible keys values.
KeyFilter.Term	Specifies criteria for selecting one segment of a Key value.
KeyHistogram	Accumulate and hold information about the distribution of Key objects in a Persistit Tree.
KeyHistogram.KeyCount	Element in a KeyHistogram that denotes the estimated number of keys in a histogram bucket.
KeyParser	Parses String values as Key or KeyFilter values.
KeyState	Represent an immutable copy of the state from a Key object suitable for use as the key of a Map.
Management.AcquisitionTimeBase	Base class for all management data structures that retain the time at which the information was recorded.
Management.BufferInfo	Exposes information about one Buffer.
Management.BufferPoolInfo	Exposes information about a BufferPool.
Management.JournalInfo	Structure that describes the current state of the journal manager.
Management.LogicalRecord	A structure that contains data about a single logical record within a page.
Management.LogicalRecordCount	A structure that returns the result of the Management.getLogicalRecordCount(java.lang.String, java.lang.String, java.lang.String, com.persistit.KeyState, com.persistit.Key.Direction, int) method.
Management.RecordInfo	A structure that contains data about a single physical record within a page.
Management.RecoveryInfo	A structure that holds information about the recovered database.
Management.TaskStatus	Structure that describes the current status of a long-running utility task.
Management.TransactionInfo	A structure that holds counts of commit, rollbacks and rollbacks since the last commit.
Management.TreeInfo	Exposes information about a Persistit Tree.
Management.VolumeInfo	Exposes information about a Volume.
Persistit	Create and manage the runtime environment for a Persistit™ database.
PersistitMap<K,V>	A persistent java.util.SortedMap over a Persistit database.
RecoveryManager	Manages the recovery process during Persistit startup.
SessionId	Identity key for a session.
StatisticsTask	Task that reports, either once or periodically, various runtime statistics.
StreamLoader	Loads Persistit records from a file or other stream in a format generated by a StreamSaver.
StreamLoader.ImportHandler	Handler for various record types in stream being loaded.
StreamSaver	Saves Persistit records to a DataOutputStream in the format expected by a StreamLoader instance.
Task	Abstract superclass of classes that perform long-running utility operations, such as export, import and integrity check.
TaskCheck	A Task which simply checks the status of another Task.
TimelyResource<V extends com.persistit.Version>	Transactionally manage multiple versions of a resource.
Transaction	Transaction context for atomic units of work performed by Persistit.
Tree	Cached meta-data about a single B-Tree within a Volume.
TreeBuilder	A mechanism for optimizing the process of loading large sets of records with non-sequential keys.
TreeSelector	Select Volumes, Trees or Keys given a pattern string.
TreeState	An immutable, inactive representation of the state of a Tree object.
TreeStatistics	Collection of AtomicLong counters representing interesting statistics in a Tree.
Value	Encapsulates the serialized form of an Object or a primitive value.
Value.OldValueInputStream	An ObjectOutputStream that reads bytes from this Value using standard Java serialization.
ValueState	Contains an immutable copy of the state from a Value object suitable for use as the key of a Map.
Volume	Represent the identity and optionally the service classes that manage a volume.
VolumeSpecification	A structure holding all the specification details for a Volume.

Enum Summary

Enum	Description
Accumulator.Type
AlertMonitor.AlertLevel	Severity of an event
Exchange.Sequence
Key.Direction	Enumeration of possible qualifiers for the traverse and remove methods.
Transaction.CommitPolicy

Exception Summary

Exception	Description
Management.WrappedRemoteException	A subclass of RemoteException that wraps a Throwable so that it can be returned to the remote client.
Persistit.FatalErrorException	An Exception created when Persistit detects a fatal internal error such as database corruption.
PersistitMap.PersistitMapException	Unchecked wrapper for PersistitExceptions that may be thrown by methods of SortedMap.
Tree.TreeVersionException	Unchecked wrapper for PersistitException thrown while trying to acquire a TreeVersion.

Annotation Types Summary

Annotation Type	Description
CLI.Arg	Annotation for parameters of command methods
CLI.Cmd	Annotation for methods that implement commands

Package com.persistit Description

Implements Persistit™'s core functionality.

Applications initialize and close Persistit through an instance of the Persistit class. A Persistit instance must be initialized through one of the initialize methods, and must be closed by the close to ensure all updates are written to disk.

Applications interact with Persistit through instances of Exchange. An Exchange has two important associated member objects, a Key and a Value. A Key is a mutable representation of a key, and a Value is a mutable representation of a value. Applications manipulate these objects and interact with the database through one of the following four general patterns:

1. Modify the Key, perform a fetch operation, and query the Value.
2. Modify the Key, modify the Value, and then perform a store operation to insert or replace data in the database.
3. Modify the Key, and then perform a remove to remove one or more key/value pairs.
4. Optionally modify the Key, perform a traverse, next or previous, then query the resulting state of Key and/or Value to enumerate key/value pairs currently stored in the database.

Additional methods of Exchange include fetchAndStore and fetchAndRemove. These atomically modify the database and return the former value associated with the Key.

Every Exchange has an associated Transaction object that represents its current transactional state. Every operation performed by any of the access or update methods of the Exchange is performed within the context of this Transaction, meaning that its result is atomic, consistent, isolated and durable (the ACID properties). By default these methods behave as if the bounded by begin commit and end calls on the Transaction. An application can group multiple operations together by explicitly invoking begin, commit and end calls. See Transaction for further information.

The Persistit database is stored in physical files managed by Volumes. A Volume contains an unbounded number of logical Trees, each of which constitutes a physical balanced tree.

IntegrityCheck provides a simple mechanism to verify the internal integrity of Volumes and/or individual Trees.

This package also includes PersistitMap which provides a persistent, fast implementation of java.util.SortedMap.

Finally, an application can obtain an instance of a Management object that exposes an API for measuring performance data, sizes and utilization of database volumes, and many other elements from the Persistit.getManagement() method. Optionally this class can be exported via Java RMI (Remote Method Invocation) to permit administration from a connected workstation.