All Classes and Interfaces
Class
Description
Represents details of an array in a field/property in a class.
This interface is used to notify instances of attach events.
This interface is implemented by listeners to be notified of
attach events.
Converts persistent attribute values (fields or properties) to different
values stored in the underlying datastore and vice versa.
Dummy converter to represent "use the implementation default for this type" when using annotations.
Representation of a boolean expression.
Representation of a byte expression.
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.
Representation of a character expression.
This class is for identity with a single character field.
Represents a class.
Enumeration of the persistence-modifier values for a class.
This interface is used to notify instances of clear events.
This interface is implemented by listeners to be notified of
clear events.
Representation of a collection in a query.
Represents details of a collection in a field/property in a class.
Annotation for a column in the database.
Represents an element in a collection/array.
Annotation for a group of columns.
Representation of an expression for a Java type that implements java.lang.Comparable.
Constant values used in JDO.
Specifies that a given type should be converted before being stored to, and after being retrieved from
the datastore using the given
AttributeConverter.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.
Represents the datastore identity of a class.
Representation of a date in a query.
Representation of a date-time type in a query.
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.
Represents the discriminator for inheritance purposes for this class.
Enumeration of the discriminator strategy values.
Annotation for the element of a collection/array relation.
Represents an element in a collection/array.
Annotation to define that the object is embedded into the table of the
owning object.
Represents embedding details of a field/property in a class.
Annotation for whether the class is only for persisting embedded into
another object.
Main class to invoke a JDO Enhancer.
Representation of an Enum in a query.
Representation of an expression in a query.
Annotation for a JDO vendor extension.
A vendor extension defined in Metadata.
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.
Represents a fetch group for a class.
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.
Represents a fetch plan for a class.
Annotation for a group of FetchPlan objects
Represents a field in a class.
Annotation for a database foreign-key.
Enumeration of the foreign-key delete/update action values.
Represents a FK constraint in an ORM context.
Annotation for a group of foreign-key constraints.
Representation of a GeometryCollection expression.
Representation of a geometry expression.
Helper builder for (DataNucleus vendor extension) Geospatial features.
Helper class for constructing messages from bundles.
Enumeration of the identity type values.
Enumeration of the id generator strategy values.
Expression representing an "IF ...
Annotation for a database index.
Enumeration of the indexed values.
Represents an index.
Annotation for a group of index constraints.
Annotation for the inheritance of the class.
Represents the inheritance of a 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.
Represents a persistent-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.
Exception thrown when an error occurs during enhancement.
Interface for a JDO Enhancer.
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.
Represents the top-level JDO metadata.
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.Interface for a type-safe refactorable JDOQL query, using a fluent API, based around expressions.
Interface for a type-safe subquery, using a fluent API.
This class represents exceptions caused when a query is cancelled by a user calling
Query.cancel().
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.
Represents join information.
Annotation for a group of joins.
Annotation for the key of a map relation.
Represents a key in a map.
Representation of a LinearRing expression.
Representation of a LineString expression.
Representation of a List in a query.
This interface is used to notify instances of load events.
This interface is implemented by listeners to be notified of
load events.
Representation of a java.time.LocalDate in a query.
Representation of a java.time.LocalDateTime type in a query.
Representation of a java.time.LocalTime in a query.
This class is for identity with a single long field.
Representation of a map in a query.
Represents details of a map in a field/property in a class.
Represents a field/property in a class/persistent-interface.
This interface provides base level definitions for all metadata components.
Representation of a MultiLineString expression.
Representation of a MultiPoint expression.
Representation of a MultiPolygon expression.
Annotation to specify that the member is not persistent.
Enumeration of the "null-value" behavior values.
Representation of a numeric expression.
Representation of an Object as an expression.
This class is for identity with a single Object type field.
This class defines the object states for JDO instances.
Representation of an Optional type in a query.
Annotation for the ordering component of an ordered container member,
such as Java Collections Framework Array and List types and Java native
array types.
Expression representing the ordering using an expression, a direction, and how to treat nulls.
Represents ordering of a collection field/property.
Represents a package within a JDOMetadata.
Expression representing a persistable object in a query (e.g alias.persistableField).
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.
Representation of a Point expression.
Representation of a Polygon expression.
Annotation for a method on a persistence capable object to be used just as
.
invalid reference
javax.jdo.listener.AttachCallback#jdoPostAttach()Annotation for a method on a persistence capable object to be used just as
.
invalid reference
javax.jdo.listener.AttachCallback#jdoPostDetach()Annotation for a method on a persistence capable object to be used just as
LoadCallback.jdoPostLoad().Annotation for a method on a persistence capable object to be used just as
AttachCallback.jdoPreAttach().Annotation for a method on a persistence capable object to be used just as
ClearCallback.jdoPreClear().Annotation for a method on a persistence capable object to be used just as
DeleteCallback.jdoPreDelete().Annotation for a method on a persistence capable object to be used just as
DetachCallback.jdoPreDetach().Annotation for a method on a persistence capable object to be used just as
StoreCallback.jdoPreStore().Annotation on a member to define it as a primary key member of a class or
persistent interface using application identity.
Represents the primary key definition of a class.
Represents a property in a class/persistent-interface.
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.Represents a named query.
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.
Represents a sequence.
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.
Representation of a string in a query.
This class is for identity with a single String field.
Representation of a subquery in a query.
Representation of a time in a query.
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.
Represents a class or interface.
Annotation for a database unique constraint.
Represents a unique constraint.
Annotation for a group of unique constraints.
Annotation for the value of a map relation.
Represents a value in a map.
Annotation for the versioning of the class.
Represents versioning of a class.
Enumeration of the version strategy values.