All Classes and Interfaces

Class
Description
This interface is used to notify instances of attach events.
This interface is implemented by listeners to be notified of attach events.
This class is for identity with a single byte field.
Annotation to specify that this class/field/property is cacheable in a Level 2 cache.
This class is for identity with a single character field.
This interface is used to notify instances of clear events.
This interface is implemented by listeners to be notified of clear events.
Annotation for a column in the database.
Annotation for a group of columns.
Constant values used in JDO.
This interface is implemented by listeners to be notified of create events.
Many JDO implementations allow instances to be cached in a second-level cache, and allow direct management of the cache by knowledgeable applications.
This class is an empty implementation of the DataStoreCache interface.
Annotation for the datastore identity of the class.
This interface is used to notify instances of delete events.
This interface is implemented by listeners to be notified of delete events.
This interface is implemented by classes that can be detached from the persistence context and later attached.
This interface is used to notify instances of detach events.
This interface is implemented by listeners to be notified of detach events.
This interface is implemented by listeners to be notified of dirty events.
Annotation for the discriminator of the class.
Enumeration of the discriminator strategy values.
Annotation for the element of a collection/array relation.
Annotation to define that the object is embedded into the table of the owning object.
Annotation for whether the class is only for persisting embedded into another object.
Annotation for a JDO vendor extension.
Annotation for a group of extensions
Instances of the Extent class represent the entire collection of instances in the data store of the candidate class or interface possibly including its subclasses or subinterfaces.
Annotation for the fetch group of a class.
FetchGroup represents a named fetch group for a specific class or interface.
Annotation for a group of fetch-group objects
Annotation for the fetch plan of a persistence manager, query, or extent.
Fetch groups are activated using methods on this interface.
Annotation for a group of FetchPlan objects
Annotation for a database foreign-key.
Enumeration of the foreign-key delete/update action values.
Annotation for a group of foreign-key constraints.
Helper class for constructing messages from bundles.
Enumeration of the identity type values.
Enumeration of the id generator strategy values.
Annotation for a database index.
Annotation for a group of index constraints.
Annotation for the inheritance of the class.
Enumeration of the inheritance strategy values.
A PersistenceCapable class that provides callback methods for life cycle events implements this interface.
This is the event class used in life cycle event notifications.
All lifecycle listeners extend from this base interface.
This class is for identity with a single int field.
This is the base class for exceptions that can be retried.
The underlying connection that is being used by a PersistenceManager.
This class represents data store exceptions that can be retried.
This class represents exceptions caused by access of an unloaded field while the instance is detached.
 
 
This is the root of all JDO Exceptions.
This class represents data store exceptions that cannot be retried.
This class represents exceptions that are fatal; that is, the condition that caused it cannot be bypassed even if the operation is retried.
This class represents errors in the implementation for which no user error handling is possible.
This class represents user errors that cannot be retried.
This class can be used by a JDO-aware application to call the JDO behavior of PersistenceCapable instances without declaring them to be PersistenceCapable.
This class is a helper class for JDO implementations.
This is a helper class to manage metadata per persistence-capable class.
This is an interface used to interrogate the state of an instance that does not implement PersistenceCapable.
This is an interface used to interrogate the state of an instance that does not implement PersistenceCapable.
Construct an instance of a key class using a String as input.
An instance of this class is thrown when attempting to create an object id when the object id constructor parameter is null.
This class represents exceptions caused by the user accessing an object that does not exist in the datastore.
This class represents optimistic verification failures.
The JDOPermission class is for operations that are reserved for JDO implementations and should not be called by other code.
This class represents exceptions caused by an attempt to update a datastore when the PMF was created as "read-only".
This class represents exceptions caused by the use of optional features not supported by the JDO implementation.
This class represents exceptions caused by exceptions thrown during execution of callbacks or listeners.
This class represents user errors that can possibly be retried.
Annotation for the join of a relation.
Annotation for a group of joins.
Annotation for the key of a map relation.
This interface is used to notify instances of load events.
This interface is implemented by listeners to be notified of load events.
This class is for identity with a single long field.
Annotation to specify that the member is not persistent.
Enumeration of the "null-value" behavior values.
This class is for identity with a single Object type field.
This class defines the object states for JDO instances.
Annotation for the ordering component of an ordered container member, such as Java Collections Framework Array and List types and Java native array types.
Annotation to specify that the class is persistence-aware.
Annotation for whether the class or interface is persistence-capable.
A class that can be managed by a binary-compatible JDO implementation must implement this interface.
This interface is used to store fields from the Object id instance.
This interface is a convenience interface that allows an instance to implement both ObjectIdFieldSupplier and ObjectIdFieldConsumer.
This interface is used to provide fields to the Object id instance.
PersistenceManager is the primary interface for JDO-aware application components.
The PersistenceManagerFactory is the interface to use to obtain PersistenceManager instances.
Enumeration of the persistence-modifier values for a field or property.
Annotation for defining the persistence of a member.
Annotation on a member to define it as a primary key member of a class or persistent interface using application identity.
Annotation for a group of named queries.
Annotation for a named query.
The Query interface allows applications to obtain persistent instances, values, and aggregate data from the data store.
A RegisterClassEvent event gets delivered whenever a persistence-capable class registers itself with the JDOImplHelper.
A "RegisterClassEvent" event gets fired whenever a persistence-capable class is loaded and gets registered with the JDOImplHelper.
Annotation for a datastore sequence.
Implementations of this interface can be used to obtain sequences.
Enumeration of the sequence strategy values.
Annotation on a member (field or property) to indicate that the member is stored serialized.
This class is for identity with a single short field.
This class is the abstract base class for all single field identity classes.
This interface is implemented by a non-binary-compatible JDO implementation to provide state interrogation for non-enhanced persistent classes.
This interface is the point of contact between managed instances of PersistenceCapable classes and the JDO implementation.
This interface is used to notify instances of store events.
This interface is implemented by listeners to be notified of store events.
This class is for identity with a single String field.
The JDO Transaction interface provides for initiation and completion of transactions under user control.
Annotation to indicate that a member (field or property) is transactional but not persistent.
Annotation for a database unique constraint.
Annotation for a group of unique constraints.
Annotation for the value of a map relation.
Annotation for the versioning of the class.
Enumeration of the version strategy values.