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.