All Classes and Interfaces
Class
Description
Absolute value.
Denotes ABS() operation on a given expression.
Abstract implementation of the
BrokerFactory
that must be subclassed for a specific runtime.Base class for factory implementations built around XML metadata files
in the common format.
Internal parser interface.
Internal serializer interface.
Base class that provides utilities to change trackers.
No-op strategy for easy extension.
Decorates another
Collection to provide additional behaviour.Base event manager that handles adding/removing listeners
and firing events.
Abstract
DataCache implementation that provides various
statistics, logging, and timeout functionality common across cache
implementations.Provides a basic instrument implementation wrapper for the data cache.
Base dictionary for the IBM DB2 family of databases.
No-op strategy for easy extension.
Domain Object is a path expression over which query is evaluated.
Abstract
BidiMap implemented using two maps.Inner class MapIterator.
Inner class EntrySet.
Inner class EntrySetIterator.
Inner class KeySet.
Inner class KeySetIterator.
Inner class MapEntry.
Inner class Values.
Inner class ValuesIterator.
Inner class View.
Provides an implementation of an empty map iterator.
Abstract base class to help build expressions.
No-op abstract visitor meant for easy extension.
No-op strategy for easy extension.
An abstract implementation of a hash-based map which provides numerous points for
subclasses to override.
EntrySet implementation.
EntrySet iterator.
HashEntry used to store the data.
Base Iterator
MapIterator implementation.
KeySet implementation.
KeySet iterator.
Values implementation.
Values iterator.
Provides a base for creating instruments.
Specialized instrumentation providers can extend this class to get basic
provider state and capabilities.
Provide a basic
IterableMap implementation.Provides basic behaviour for decorating an iterator with extra functionality.
An abstract implementation of the
JDBCListener
listener.Abstract
SavepointManager implementation that
delegates to the subclass for savepoint operations on the active
Connection.Abstract sequence implementation.
Abstract pair class to assist with creating
KeyValue
and Map.Entry implementations.Abstract implementation of the
LifecycleListener interface
which delegates events to a single method.An abstract implementation of a hash-based map that links entries to create an
ordered map and which provides numerous points for subclasses to override.
EntrySet iterator.
KeySet iterator.
LinkEntry that stores the data.
Base Iterator that iterates in link order.
MapIterator implementation.
Values iterator.
Decorates another
List to provide additional behaviour.Abstract
LockManager implementation.A simple implementation of the
Log interface.A collection proxy designed for collections backed by extremely large
result sets in which each call to
AbstractLRSProxyCollection.iterator() may perform a database
query.A map proxy designed for maps backed by extremely large result sets in
which each call to
AbstractLRSProxyMap.get(java.lang.Object) or AbstractLRSProxyMap.containsKey(java.lang.Object) may perform a
database query.Implements the managed persistent type and its attributes.
Selects if the attribute type matches the given Java class.
Selects plural attribute of given element type.
Affirms if a given element satisfy a condition.
Affirms if the given attribute is a Singular attribute.
Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
Abstract Pair class to assist with creating correct
Map.Entry implementations.Provides a base decorator that allows additional functionality to be
added to a
Map.Entry.Abstract implementation provides a set of generic utilities for detecting
persistence meta-data of Field/Member.
Abstract
MetaDataFactory that provides default implementations
of many methods.Abstract base class for random-access result lists.
The base class for all enhancement mojos.
Processes Application model classes and generate the DDL by running the
OpenJPA MappingTool.
Base class for OpenJPA maven tasks.
Provides a base decorator that enables additional functionality to be added
to an OrderedMap via decoration.
Abstract base class which implements core PCData behavior.
Abstract implementation of
PCResultObjectProvider
that implements ResultObjectProvider.getResultObject()
by assembling the necessary information about the object to be loaded.Provides a basic instrument implementation wrapper for the prepared query cache.
Abstract no-op product derivation for easy extension.
An abstract implementation of the Query interface.
Abstract
QueryCache implementation that provides various
statistics, logging, and timeout functionality common across cache
implementations.A default implementation of query statistics for the Query result cache.
Provides a basic instrument implementation wrapper for the query cache.
An abstract implementation of a hash-based map that allows the entries to
be removed by the garbage collector.
A MapEntry implementation for the map.
Reference type enum.
Abstract implementation of
RemoteCommitProvider.A
Result implementation designed to be subclassed easily by
implementations.Abstract base class for read-only result lists.
Abstract base class for sequential result lists.
Serializable subclass of AbstractListDecorator.
Serializable subclass of AbstractSetDecorator.
Decorates another
Set to provide additional behaviour.Provides a base decorator that enables additional functionality to be added
to a Map via decoration.
OrderedMapIterator implementation.
Dictionary for the SQL Server databases (Sybase and MS SQL Server).
BrokerFactory implementation for use with the
AbstractStoreManager.Abstract store manager implementation to ease development of custom
OpenJPA back-ends.
Abstract
StoreQuery that implements most methods as no-ops.Abstract
StoreQuery.Executor that implements most methods as no-ops.No-op strategy for easy extension.
Ant tasks all have a nested
<config&rt; tag, which uses
the configuration as a bean-like task.Abstract implementation of the
TransactionListener interface
that provides no-op implementations of all methods.Provides basic behaviour for decorating an iterator with extra functionality
without committing the generic type of the Iterator implementation.
Base update manager with common functionality.
Executes customized mapping updates.
Abstract validation class which provides base validation methods.
No-op implementations of
ValueHandler interface methods.No-op strategy for easy extension.
Represents access styles for members of a class and field through a
5-bit integer.
Dictionary for Access via DataDirect SequeLink and DataDirect ODBC
FoxPro driver.
Type of the result of an aggregate operation
An aggregate listener aggregates data produced by an ExpressionQuery.
Denotes (e1 AND e2) predicate.
Helper class to stringify annotation declarations.
Persistence annotation mapping parser.
Serializes persistence mappings as annotations.
Persistence annotation metadata parser.
Serializes persistence metadata as annotations.
JAXB xml annotation metadata parser.
Annotation processing tool generates source code for a meta-model class given
the annotated source code of persistent entity.
Utility class for manipulating application object ids.
Generates a class appropriate for use as an application identity class.
Run flags.
Interface implemented by metadata factories that can load non-existant
object id classes.
Executes the application id tool on the specified files.
A list of arguments to a multi-argument function.
Extended
IllegalArgumentException.Multiple arguments to a function call.
A single expression that holds an array of values.
Utilities for dealing with a simple state image consisting of an
Object[] of field values with one extra index containing a
BitSet of loaded fields.Utility methods to deal with ASM bytecode
Listener for when a detached instance is attached.
Handles attaching instances.
Instances of this interface can convert a positional index for a
FieldMetaData that uses property access into the underlying
field name.Annotates a persistent type for
audit.Operations of persistent type that can be audited.
Carries immutable information about an audited persistent instance.
A default auditor that simply prints the audited instances.
Controller for audit facility.
An auditor is responsible for recoding the audited information.
State clearing constants.
The possible settings for the auto-clear behavior of an
OpenJPAEntityManager.Bit flags for when to automatically detach the entire persistence context.
The possible settings for the auto-detach behavior of an
OpenJPAEntityManager.Automatic Commons DBCP pooling or Simple non-pooling driver data source.
Implementation of the
ManagedRuntime interface that searches
through a set of known JNDI locations and method invocations to locate the
appropriate mechanism for obtaining a TransactionManager.Denotes AVG() on a given Expression.
Base 16 encoder.
A provider for multiple result sets.
Batch update manager that writes the SQL in object-level operation order.
Batch update manager that writes the SQL in object-level operation order.
Batch prepared statement manager implementation.
Performs a callback method on a cached bean instance.
Notified when transactions begin.
Denotes e1 BETWEEN(e2 AND e3) Expression.
Defines a map that allows bidirectional lookup between key and values.
Enumeration of conditional operator that operates on ordered pair of
expression to generate a predicate.
Enumeration of functional operator that operates on ordered pair of
expression to generate another expression.
An expression resulting from a binary operation on two expressions.
Handler for blob values.
OpenJPAId subclass appropriate for boolean fields.Defines how a
Boolean or boolean value
gets stored in the database by default.Factory which is being used to create the active
BooleanRepresentation.BooleanRepresentation which takes 2 strings for true and false representations
as constructor parameter;
A boolean
Value.Helper methods for acquiring
BrokerFactory objectsException recognized by
bootstrap framework.Defines a map that is bounded in size.
Performs a breadth-first walk of a given
Graph,
notifying visitors as it sees each node.The broker is the primary interface into the OpenJPA runtime.
Factory for
Broker instances.Event fired when a
BrokerFactory is created.EventManager responsible for notifying listeners of
BrokerFactoryEvents.Interface for listening to
BrokerFactoryEvent objects.Value type used to represent the
BrokerFactory.Concrete
Broker.Unique id for state managers of new datastore instances without assigned
object ids.
Custom
PluginValue that can efficiently create BrokerImpl
instances.This is a simple ClassLoader that delegates to the Bundle
and is used by the PersistenceUnitInfo
OSGi helper class and methods.
Handler for byte array values.
Control how enhanced bytecode is written.
OpenJPAId subclass appropriate for byte fields.This class came from the Apache Commons Id sandbox project in support
of the UUIDGenerator implementation.
Dictionary for Intersystems Cache.
A policy determines whether a given entity should be cached and if true, in which named partition of the
cache.
Fixed-size map that has ability to pin/unpin entries and move overflow to
a backing soft map.
Responsible for marshalling and unmarshalling objects between memory and
durable cache.
Validation policies are responsible for computing whether or not a
cached data structure is valid for the current context.
Default
CacheMarshaller implementation that writes data
to a specified file and reads data from a specified file or URL.A configuration value for handling and accessing cache marshallers.
Counts number of read/write requests and hit ratio for a cache in total and
per-class basis.
The default CacheStatistics(SPI) implementation.
The provider extensions to the CacheStatistics interface.
A calendar-modified value.
Exception type thrown when an error occurs in a callback.
The possible settings for the callback behavior of an
OpenJPAEntityManager.Callback handling constants.
Configurable options for callbacks.
A path represents a traversal into fields of a candidate object.
Represents a traversal through a field.
Interface for the construction of case expressions
Custom SAX parser used by the system to quickly parse metadata files
for classes.
Helps serialize metadata objects to package and class elements.
Interface for components that track changes to containers at a
fine-grained level.
Handler for char array values.
Handler for char array values.
OpenJPAId subclass appropriate for char fields.Filter that looks for classes with one of a set of annotations.
Parser used to resolve arguments into java classes.
Marker interface specifying to use the expected class of the relation
as criteria in the join.
Service to load classes dynamically at runtime.
Specialization of metadata for relational databases.
Information about the mapping from a class to the schema, in raw form.
Contains metadata about a persistent type.
Iterator over all metadata resources that might contain the
metadata for a given class, starting with the most general.
Stores the class name along with each database object record.
Helper class to transit from BCClass to ASM
Iterator over directories in the classpath.
Redefines the method bodies of existing classes.
Interface to customize the loading of classes under OpenJPA.
Default class resolver implementation.
Mapping from a class to a relational schema.
Specialization of the
TableJDBCSeq that maintains a
separate sequence count per-class.Various helper methods to deal with Classes
Helper to keep track of generated methods when using ASM ClassWriter.
Generic interface for components that can be cleared so that helpers can treat them in a generic
way.
Cron-style clearable eviction.
Listener for when persistent state is cleared from an instance.
Handler for clob values.
Generic interface for components that can be closed so that helpers
can treate them in a generic way.
Computes closure of a collection of managed objects.
An in-memory representation of a coalesce expression
Coalesce expression.
Encapsulates some common Java source code formatting options.
Generates Java class code from metadata.
Change tracker that can be used for collections.
Default
CollectionChangeTracker.A collection-valued input parameter in an in-expression.
Expression state.
Represents a database column.
Default rule for column definition.
Default rule for column names.
Metadata about column I/O in a specific context.
Allows the specification of multiple columns for complex mappings.
Uses a one or more column(s) and corresponding version object.
Implementations of this interface can be adorned with comments.
LogFactory implementation that delegates to the commons logging
framework.Adapts a commons logging log to the
Log interface.A
Comparator that compares Comparable
objects.A ComparatorChain is a Comparator that wraps one or more Comparators in
sequence.
Defines a comparison style to be applied for query-by-example attribute comparison.
Default implementation.
Struct encompassing backwards-compatibility options.
Simple logger sets log level from javac compilers annotation processing
options
-Alog=TRACE|INFO|WARN|ERROR and uses the processing
environment to determine the log output stream.Concatenate one string with another.
Denotes CONCAT(e1,e2,..)
A
DataCache implementation that is optimized for concurrent
access.This class implements a HashMap which has limited synchronization.
A highly concurrent map.
A
QueryCache implementation that is optimized for concurrent
access.This class implements a HashMap which has limited synchronization
and reference keys or values(but not both).
A concurrent set whose values may be stored as weak or soft references.
Enumerates conditional operator that operates on two predicates to generate
another predicate.
This interface provides a mechanism for notifying interested
objects when configuration events occur.
Interface for generic configuration objects.
Default implementation of the
Configuration interface.Implementations of this interface can populate
Configurations in
some environment-specific way.Utility methods dealing with configuration.
Connection decorator that can configure some properties of the
underlying connection.
A connection decorator can wrap
Connections before they are
returned to the user to add functionality.Struct to hold data about the current connection state.
The possible values for use when configuring the connection retain
behavior for an
OpenJPAEntityManager.Connection retain mode constants.
Interface for any query constant value.
Static String constants
A table constraint.
Standard update manager, capable of foreign key constraint evaluation.
An abstract container mapping that handles traversing the
join to examine the size of the relation.
Table for array, collection, or map elements.
JPQL / Criteria Query Context
Denotes COUNT(e) Expression.
Factory for Criteria query expressions.
A visitor for Criteria Expression nodes.
An abstract implementation that can detect cycles during traversal.
A visitor to register Parameter expression of a query.
Denotes CURRENT_TIME(), CURRENT_DATE() and CURRENT_TIMESTAMP() expressions.
Interface that must be implemented by any level 2 cache used by
OpenJPA.
Caching characteristics for this class.
Interface for providing instrumented data cache metrics and operations.
A JMX-specific instrument for the data cache
Simple MBean interface for providing instrumented data cache metrics
and operations.
Manages the system's data and query caches.
Default data cache manager provides handle to utilities PCDataGenerator, ClearableScheduler
and CacheDistributionPolicy for the cache operation.
Specialized
PCData implementation for data caching.A
PCDataGenerator instance which generates properly
synchronized instances suitable for use in the cache.Simple interface to give access to expiration time.
Specialized
PCData implementation for data caching.DataCache Retrieve Modes.
StoreManager proxy that delegates to a data cache when possible.
DataCache Store modes
Factory for
DataSource objects.Provies basic logging facilities to a DataSource.
A unary operator that executes a datastore specific function with zero or more arguments.
Describes how to generate a value for a field.
Surrogate datastore identity column.
OpenJPAId subclass appropriate for Date fields.Dictionary for IBM DB2 database.
Commons DBCP basic pooling driver data source.
Class which allows the creation of SQL dynamically, in a
database agnostic fashion.
Used by some mappings to represent data that has already been
serialized so that we don't have to serialize multiple times.
Factory class to instantiate a dictionary.
Encapsulates a database identifier.
Database identifier types.
The default DBIdentifier rule.
An interface for DB identifier utility-style operations.
Delegating data source that maintains a list of
ConnectionDecorators.A default implementation that selects the cache by the type of the given managed instance.
ArrayList proxy with delay loading capability.
A collection change tracker used by delay loaded collections.
HashSet proxy with delay loading capability.
LinkedHashSet proxy with delay loading capability.
LinkedList proxy with delay loading capability.
PriorityQueue proxy with delay loading capability.
Implemented by proxy classes which are delay-load capable.
TreeSet proxy with delay loading capability.
Vector proxy with delay loading capability.
Delegating broker that can also perform exception translation
for use in facades.
Delegating broker factory that can also perform exception translation
for use in facades.
CallableStatement that delegates to an internal statement.Wrapper around an existing connection.
Wrapper around a DatabaseMetaData instance.
Delegating data cache that can also perform exception translation for
use in facades.
Wrapper around an existing data source.
Delegating extent that also can perform exception translation for use
in facades.
Delegating fetch configuration that can also perform exception
translation for use in facades.
Delegating fetch configuration that can also perform exception
transation for use in facades.
Delegates to another
Joinable after doing column
translation.Base class for factory instances that use a delegate.
Wrapper around an existing statement.
Delegating query that can also perform exception translation
for use in facades.
Delegating query cache that can also perform exception translation for
use in facades.
Delegating result list that can also perform exception translation
for use in facades.
Wrapper around an existing result set.
Delegating sequence that can also perform exception translation for use
in facades.
Wrapper around an existing statement.
Base class for store manager decorators that delegate to another
store manager for some operations.
Listener for when a persistent instance is deleted.
Dependent field marker.
Performs a depth-first analysis of a given
Graph, caching
information about the graph's nodes and edges.Dictionary for Apache Derby (formerly Cloudscape).
Detached state.
Internal state manager for detached instances.
Implementation of
OpenJPAStateManager designed to retrieve
values from a detached instance, including when managed by a
DetachedStateManager.Listener for when a persistent instance is detached.
Handles detaching instances.
Handles detaching instances.
Detach options.
Public to allow reflection.
Public to allow reflection.
Detach loaded state.
Constants for which fields to include in the detach graph.
The possible settings for the detachment behavior of an
OpenJPAEntityManager.Listener for when a persistent instance becomes dirty.
Handles determining the object class of database records.
Information about the mapping from a discriminator to the schema, in
raw form.
Handles determining the object class of database records.
Discriminator mapping strategy.
Denotes DISTINCT(e) Expression.
An immutable list that imposes uniqueness on its member.
Extension to Broker to allow access to
virtual data store.Extension to BrokerFactory to allow dynamically add/remove slices.
A specialized Broker to associate slice identifiers with the StateManagers as
they are persisted in a cascade.
A configuration for multiple data stores, each referred as slice.
A virtual connection that contains multiple physical connections.
A virtual datasource that contains many physical datasources.
A factory for distributed JDBC datastores.
A distributed configuration that is a ordered collection of
JDBCConfigurations.
A specialized configuration embodies a set of Slice configurations.
A virtual PreparedStaement that delegates to a set of actual
PreparedStatements.
Extension with slice locking policy.
A chain of ResultSet.
A virtual Statement that delegates to many actual Statements.
A specialized
Store Manager that encapsulates multiple concrete Store Managers
using Distributed Template (or Composite) Design Pattern.A template for multiple Statements being executed by multiple connections.
Policy to select one of the physical databases referred as slice
in which a given persistent instance will be stored.
Implements a default distribution policy to store the given
instance to a randomly selected available slice.
Denotes e1/e2 Expression.
The DocTypeReader can be used to dynamically include a
DOCTYPE declaration in an XML stream.Domain objects define the domain over which a query operates.
OpenJPAId subclass appropriate for double fields.A double
Value.A DataSource that allows additional configuration options to be set
into it, so that it can wrap a JDBC driver or other DataSource.
Inner class MapIterator.
Internal sorted map view.
Instances that implement this marker interface are dynamically-generated
subtypes of managed types that were loaded before being enhanced.
Factory whose schema group dynamically fills itself with information
as mappings validate themselves in their
map method.Interface for dynamically generated classes.
Factory for creating new
DynamicStorage classes.Determines how to eager-fetch a field.
Eager fetch mode constants.
Simple, non-lazy ResultList implementation
A graph edge.
Marker interface specifying to use the expected class of the array,
collection, or map element relation as criteria in the join.
Array, collection, or map element column.
Allows the specification of multiple element columns for complex
mappings.
Dependent array, collection, or map element marker.
Embedded mapping information for an array, collection, or map
element.
Handler for embedded objects as elements of a collection or map.
Foreign key on array, collection, or map element columns.
Index on array, collection, or map element columns.
Array, collection, or map element join column.
Allows the specification of multiple array, collection, or map element
columns for compound joins.
Indicates that the annotated array, collection, or map's elements are
not entirely polymorphic.
Array, collection, or map element mapping strategy.
Indicates the persistent element type of an array, collection, or map
field, if different than the declared element type.
Else clause in a Case Statement.
Interface for field strategies that can managed fields of
embedded-element, embedded-key, and embedded-value objects.
Class mapping for embedded objects.
Embedded mapping information.
Mapping for an embedded persistent object.
Base class for embedded value handlers.
Dictionary for Empress using ODBC server combined with their
type 2 driver.
Provides an implementation of an empty iterator.
Provides an implementation of an empty map iterator.
Provides an implementation of an empty ordered iterator.
Provides an implementation of an empty ordered map iterator.
Interface for providing encryption/decryption capabilities to the OpenJPA
runtime.
Notified when transactions end.
A special ClassLoader to handle classes currently under bytecode enhancement.
Keep track of classes under enhancement.
Conflict with existing entity.
Implementation of
EntityManagerFactory that acts as a
facade to a BrokerFactory.Plugin type used to represent the
EntityManagerFactory.Implementation of
EntityManager interface.Missing entity.
Denotes ENTRY(e) on a path.
Adapts a Map entrySet to the MapIterator interface.
Value handler for JDK1.5 enum field types.
Denotes e1 = e2 Expression.
Basic event manager interface.
Interface supplying additional exception information.
Throw a
ObjectNotFoundException when an orphaned key is discovered.Utility methods for externalizing and handling exceptions.
Denotes EXISTS(SubQuery) Expression.
An in-memory representation of an
Expression.Expression tree context.
An event indicating the expiration of an object from the data cache,
or an expiration of a result list from the query cache.
An entity that wishes to be notified when cache keys expire.
Interface for a set of conditions that must be met for the query
to be true.
Instances of this interface can be used either as select list items or as
predicate operands.
The ExpressionFactory must be implemented by a particular runtime
to form
Expressions in its native query language.Parser for query languages that will be used by a
ExpressionQuery.Implementation of an expression-based query, which can handle
String-based query expressions such as JPQL and JDOQL.
Provides support for queries that hold query information
in a
QueryExpressions instance.The DataStoreExecutor executes the query against the
implementation's overridden
ExpressionStoreQuery.DataStoreExecutor.executeQuery(org.apache.openjpa.kernel.StoreQuery, java.lang.Object[], org.apache.openjpa.kernel.StoreQuery.Range) method.Runs the expression query in memory.
Visits nodes of a query expression tree.
Expression tree state.
Vendor extensions.
Representation of all members of a persistent class.
An extent is a logical view of all instances of a class.
Representation of all members of a persistent class.
An extent is a logical view of all instances of a class.
Declares a method that transforms the field value to its datastore
equivalent.
Maps field values to their datastore equivalents.
Declares a method that transforms the datastore value to its field
equivalent.
Includes a persistent attribute in a
FetchGroup.Allows configuration and optimization of how objects are loaded from
the data store.
Allows configuration and optimization of how objects are loaded from
the data store.
Configurable state shared throughout a traversal chain.
The fetch direction to request when creating statements.
Captures fetch group meta-data.
Fetch group definition.
Fetch groups holder.
Interface used for the result of a fetch join.
Type of fetching to employ.
Value type used to represent fetch modes.
Denotes a path used in fetch join.
The fetch plan allows you to dynamically alter eager fetching
configuration and other aspects of data loading.
Implements FetchPlan via delegation to FetchConfiguration.
FetchStatisticsAuxEnhancer adds the call back function to each persistent fields in the persistent entity which
will invoke the hit method from FetchStatsCollector whenever the field is fetched at runtime.
FetchStatsCollector aggregates fetch statistics and outputs the data periodically (10 minutes).
Consumes persistent field values.
Manages persistent fields.
Specialization of metadata for relational databases.
Information about the mapping from a field to the schema, in raw form.
Metadata for a managed class field.
Maps a persistent field to the relational schema.
Supplies persistent field values.
Iterator over a file, or over all metadata resources below a given directory.
Utility operations on files.
Factory that uses an XML schema file to construct the system schema.
A strategy to fill data into a
ResultShape.Fills an array of given type.
Populate an instance by simply assigning the 0-th element of the input values.
Create and populate a bean by invoking setter methods identified by alias name with each array
element value as argument.
Populate an instance created by given factory using a given put(key,value) method.
Construct and populate an instance by invoking the put method
with each alias as key and element of the given array of values.
Construct and populate an instance by the given constructor and arguments.
Decorates another
Iterator using a predicate to filter elements.A filter listener extends expression filters with custom functionality.
Helper methods for dealing with query filters.
The simplified public view of any non-operator in a query filter,
including constants, variables, and object fields.
Subtype of
BrokerImpl that automatically closes itself during
finalization.Allows facades to control the particulars of the find operation
through callbacks.
A cache to create and maintain
finder queries.Implementation of FinderCache for JDBC.
A finder query is a query for an instance of a class by its primary key.
Implements Finder Query identified by ClassMappping for SelectExecutor that
can be executed to generate Result.
Policy to select one or more of the physical databases referred as
slice in which a given finder will be executed.
Dictionary for Firebird.
Mapping for classes mapped to their superclass table.
OpenJPAId subclass appropriate for float fields.Notified on transaction flush.
Represents a database foreign key; may be a logical key with no
database representation.
Foreign key definition.
Foreign key actions.
A specialization of
Properties that stores its contents
in the same order and with the same formatting as was used to read
the contents from an input stream.Dictionary for Visual FoxPro via DataDirect SequeLink
and DataDirect ODBC FoxPro driver.
Mapping for when the class maps all fields to its own table.
General case expression.
General exception type.
Utility methods when generating classes, including at runtime.
Represents a store sequence.
Represents a store sequence.
Implementations of this interface may perform additional
generic configuration with any key-value pairs that cannot be set
into the object via the normal
Options.setInto(java.lang.Object) means.Object provider implementation wrapped around a generic
Result.Returns the SQL alias of the named column for use in a query.
Graph representation using the adjacency list form.
A helper interface that allows third parties to be notified of
graph events during graph traversals
Denotes e1 >= e2 Expression.
Denotes e1 > e2 Expression.
Dictionary for H2 ({@link http://www.h2database.com}).
Mapping for a collection of values in a separate table controlled by a
ValueHandler.Mapping for a single-valued field that delegates to a
ValueHandler.Mapping for a map of keys and values both controlled by
ValueHandlers.Mapping for a map whose keys are controlled by a
ValueHandler
and whose values are relations to other persistent objects.Utility methods for strategies using value handlers.
Display help information on openjpa-maven-plugin.
Call
Call
mvn openjpa:help -Ddetail=true -Dgoal=<goal-name> to display parameter details.Dictionary for HerdDB.
Manages query hint keys and handles their values on behalf of a owning
QueryImpl.Converts a given user-specified value to a target type consumable by the kernel.
Convert the enum value to an enumerated set of constants.
Converts an OpenJPA specific enum to an equivalent kernel constant.
Converts a String to an integer.
Dictionary for HyperSQL (HSQLDB) database.
Datastore identity type.
Base interface for identifiers.
The IdentifierConfiguration interface.
Base identifer implementation.
The standard identifier rule.
Base IdentifierUtil interface.
Implementation class for the base identifier impl.
Handler for simple type and string values.
Helper for OpenJPA back-ends.
Represents a database index.
Index definition.
Denotes INDEX(e) Expression.
Find the index of one string within another.
Denotes e1 IN (e2) Expression.
Dictionary for Informix database.
Comparator that keeps classes in inheritance order.
Expression factory implementation that can be used to execute queries
in memory.
A
SavepointManager implementation which stores all data in memory.Object provider implementation wrapped around a
Select.Interface that must be implemented by instruments.
Factory for obtaining an
Instrumentation instance.The instrumentation level can be used to indicate if and when an instrument will be
automatically started and stopped.
Managers of instrumentation providers must implement this interface.
An implementation of an instrumentation manager.
Pluggable instrumentation providers (ex.
Dictionary for Borland Interbase.
Exception type for internal errors.
OpenJPAId subclass appropriate for int fields.An int
Value.Extended
IllegalStateException.Exception type thrown when attempting to execute an operation that
is not allowed by the current state.
Base discriminator strategy that determines the class of database
records using a column holding a value mapped to a class, and limits
SELECTs using an IN (...) statement.
Declares the logical inverse of a field.
Class which manages inverse relations before flushing
to the datastore.
Implementation of the
ManagedRuntime interface that uses
a static method call to find the TransactionManager.String reference of a managed object.
Denotes e IS NULL Expression.
Isolation levels for use in
JDBCFetchPlan.setIsolation(org.apache.openjpa.persistence.jdbc.IsolationLevel).Defines a map that can be iterated directly without needing to create an entry set.
An IteratorChain is an Iterator that wraps a number of Iterators.
Helper class to obtain the Privilege(Exception)Action object to perform
Java 2 doPrivilege security sensitive function call in the following
methods:
AccessibleObject.setAccessible
Class.forName
Class.getClassLoader
Class.getDeclaredField
Class.getDeclaredFields
Class.getDeclaredMethod
Class.getDeclaredMethods
Class.getProtectionDomain
Class.getResource
Class.newInstance
ClassLoader.getParent
ClassLoader.getResource
ClassLoader.getResources
ClassLoader.getSystemClassLoader
File.deleteOnExit
File.delete
File.exists
File.getAbsoluteFile
File.getAbsolutePath
File.getCanonicalPath
File.listFiles
File.length
File.isDirectory
File.mkdirs
File.renameTo
File.toURL
FileInputStream new
FileOutputStream new
System.getProperties
InetAddress.getByName
MultiClassLoader new
ServerSocket new
Socket new
Socket.accept
System.getProperty
Thread.getContextClassLoader
Thread.setContextClassLoader
Thread new
TemporaryClassLoader new
URL.openStream
URLConnection.getContent
ZipFile new
AnnotatedElement.getAnnotations
AnnotatedElement.getDeclaredAnnotations
AnnotatedElement.isAnnotationPresent
jakarta.validation.Validator.validate
jakarta.validation.Validation.buildDefaultValidatorFactory
If these methods are used, the following sample usage patterns should be
followed to ensure proper privilege is granted:
Iterator over all metadata resources in a given resource addressed by a jar:file URL.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
Java SQL type constants.
Type constants for managed fields.
Utilities for dealing with different Java vendors.
Utilities for dealing with different Java specification versions.
Dictionary for Borland JDataStore
SavepointManager implementation that uses JDBC 3 savepoints
to store state.JDBC extension to the
AggregateListener.BrokerFactory type for use with the JDBC runtime.
Configuration that defines the properties necessary to configure
runtime and connect to a JDBC DataSource.
Default implementation of the
JDBCConfiguration interface.A JDBC event.
Manages the firing of
JDBCEvents.Expression factory implementation that can be used to execute queries
via SQL.
JDBC extensions to OpenJPA's
FetchConfiguration.JDBC extensions to OpenJPA's
FetchConfiguration.Configurable JDBC state shared throughout a traversal chain.
JDBC extensions to the fetch plan.
JDBC extensions to the fetch plan.
JDBC extension to the
FilterListener.A listener for all
JDBCEvents that occur.Extension of the
LockManager interface with methods for
datastore locking during the select and load process.Sets JDBC-specific JPA specification defaults.
Sets JDBC as default store.
Specialization of the the
Seq interface to provide information
on the schema needed by this sequence.Adds additional aliases to base
SeqValue.Represents the JDBC store.
StoreManager plugin that uses JDBC to store persistent data in a
relational data store.
Connection returned to client code.
JDBC query implementation.
Deprecated.
Deprecated.
Use
matches() instead.Interface for JEST commands.
Supported format monikers.
An operational context combines a
persistence context and a HTTP execution
context expressed as a request and response.A specialized HTTP servlet to interpret HTTP requests as Java Persistent API commands
on a running persistence unit.
JMS-based implementation of
RemoteCommitProvider that
listens for object modifications and propagates those changes to
other RemoteCommitProviders over a JMS topic.Interface for JMX-specific instruments
A simple MBean JMX instrumentation provider
Implementation of the
ManagedRuntime interface that uses JNDI to
find the TransactionManager.Represents a SQL join.
Represents a value that can be joined to.
Path resulting by joining from a parent path via an attribute.
Tracks joins made when traversing relations in a select.
Type of join syntax to use.
Constants for ways of describing joins in SQL.
Helper class for switching between OpenJPA's JPA facade and the underlying
Broker kernel.
Enumerates configuration property keys defined in JPA 2.0 Specification.
An operating context provides a
persistence context and utility functions within
which all JEST commands execute.Token literal values and constants.
Builder for JPQL expressions.
Base node that will be generated by the JPQLExpressionBuilder; base
class of the
SimpleNode that is used by JPQL.Public for unit testing purposes.
Utility for converting elements to JPQL string fragments.
Parser for JPQL queries.
Token Manager.
A generic interface for a JSON encoded instance.
A generic interface for a JSON encoded instance.
A JSON instance for persistence.
A JSON instance for persistence.
An array of objects.
An array of objects.
A map whose key or value can be JSON.
A map whose key or value can be JSON.
Marshals a root instance and its persistent closure as JSON object.
Marker interface specifying to use the expected class of the map key
relation as criteria in the join.
Map key column.
Allows the specification of multiple map key columns for complex
mappings.
Dependent map key marker.
Embedded mapping information for a map key.
Denotes KEY(e) Expression.
Foreign key on map key columns.
Index on map key columns.
Map key join column.
Allows the specification of multiple map key columns for compound
joins.
Indicates that the annotated map's keys are not entirely polymorphic.
Map key mapping strategy.
Indicates the persistent key type of a map field, if different than the
declared type.
Defines a simple key value pair.
Lazy forward-only result list.
Factory that uses database metadata to construct the system schema.
Denotes LENGTH(e) Expression.
Denotes e1 <= e2 Expression.
Denotes e1 < e2 Expression.
A lifecycle listener that responds to callbacks rather than events.
Lifecycle event on a persistent instance.
Manager that can be used to track and notify listeners on lifecycle events.
Interface that facades to other lifecycle listener interfaces can
implement to choose which events to respond to based on their delegate.
Extended list that tracks what event types its elements care about.
Interface for listening to all
LifecycleEvents.Information about lifecycle events for a managed type.
Denotes e1 LIKE e2 Expression.
A
Map implementation that maintains the order of the entries.Converts an
Iterator into a ResettableListIterator.A basic
ResultList implementation that wraps a normal list.A result object provider wrapped around a normal list.
A literal value in a filter.
Interface for any literal value.
Denotes a Literal Expression.
Fetch group loaded when the annotated field/property is loaded.
Listener for when state is loaded into a persistent instnace.
Direct mapping from a stream value to a column.
Constraint over local table columns, as opposed to a foreign key which
spans tables.
The Localizer provides convenient access to localized
strings.
A
Message can provide a localized message via the
Localizer.Message.getMessage() method call, and can also provide the original key,
package, and substitution array that were used to assemble the message.Denotes LOCATE(e1, e2, n) Expression.
Exception indicating that locks on one or more objects could not be acquired.
Standard object lock levels.
Handles obtaining and releasing locks on objects.
Defines lock scope levels used for MixedLockManager.
Helper methods translate between JPA-defined pessimistic lock scope and
OpenJPA internal lock scope levels.
Pessimistic lock timeout violation.
Logging interface that is independent of other logging frameworks.
LogFactory implementation that delegates to the Log4J-2.x framework.Adapts a Log4J2 logger to the
Log
interface.LogFactory implementation that delegates to the Log4J 1.x framework.Adapts a Log4J logger to the
Log
interface.Factory for log instances.
Base type that aids in adapting an external log framework to the
LogFactory.Default
LogFactory implementation.A
ConnectionDecorator that creates logging connections and
ReportingSQLExceptions.Interface that allows customization of what to do when
SQLWarnings occur.Logical Predicate combines two predicates with a logical operator.
A logical union made up of multiple distinct selects whose results are
combined in memory.
A callback used to create the selects in a SQL union.
Log a message when an orphaned key is discovered.
Many standard components log to
OutputStreams.OpenJPAId subclass appropriate for long fields.Denotes LOWER(e) Expression.
Large result set field marker.
Interface implemented by collection strategies so that they can
support large result set collections.
Interface implemented by map strategies so that they can
support large result set maps.
Marker interface for large result set proxies.
Large result set collection.
Algorithm to use for computing the size of an LRS relation.
Ways of calculating the size of large result sets.
A
Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.Extension of the commons
LRUMap that can change its
maximum size.Redefines the method bodies of existing unenhanced classes to make them
notify state managers of mutations.
Instances of this interface can provide an underlying instance.
The annotated interface should be treated as a managed interface by OpenJPA.
This interface must be implemented by concrete plugins to application
servers in order to integrate the OpenJPA runtime in a managed environment.
Change tracker that can be used for maps.
Default
MapChangeTracker.Simple configuration provider that sets configuration based on a
provided map.
Returns the Map.Entry<K,V> of a map value.
Expression state.
Defines an iterator that operates over a
Map.Returns the key of a map value.
Expression state.
Generates default names for tables, columns, indexes, constraints, etc.
Default implementation of
MappingDefaults.Handles the complex logic of creating a
MetaDataFactory for
combined metadata and mapping.Base class storing raw mapping information; defines utility methods for
converting raw mapping information to full mapping to the schema.
Supplies default foreign key information.
Supplies default table information.
Allows override of complex embedded or superclass mappings.
Allows override of complex embedded or superclass mappings.
Repository of object/relational mapping information.
Handles the complex logic of creating a
MappingRepository for
a given configuration.Installer used during mapping that attempts to use the given mapping
information (if any), and fails if it does not work.
Tool for manipulating class mappings and associated schema.
Run flags.
Helper used to import and export mapping data.
Executes the
MappingTool on the specified files.Base class for map mappings.
Value produced by a mathematical operation on two values.
Database dictionary for using SAP's MaxDB.
Mapping for serialized fields on a dictionary that has a maximum embedded
BLOB size.
Mapping for byte array fields on a dictionary that has a maximum embedded
BLOB size.
Mapping for CLOB character array on a dictionary that has a maximum
embedded CLOB size.
Mapping for CLOB string on a dictionary that has a maximum embedded
CLOB size.
Denotes MAX(e) Expression.
Denotes e1 MEMBER OF e2 Expression.
Persistent attribute according to JPA 2.0 metamodel.
Represents attributes declared as java.util.Collection<E>.
Represents the keys of java.util.Map<K,V> in managed type <X> as a pseudo-attribute of type
java.util.Set<K>.
Represents attributes declared as java.util.List<E>.
Represents attributes declared as java.util.Map<K,V> in managed type <X>.
An attribute of a Java type.
Root of multi-cardinality attribute.
Represents attributes declared as java.util.Set<E>.
Represents single-valued persistent attributes.
Result that merges multiple result delegates.
Comparator for ordering result rows.
A result object provider that merges multiple result object provider
delegates.
Performs maintenance tasks on the metadata caches accessible via the
CacheMarshaller architecture.Allows us to access configuration through metadata in a generic way.
Populates new metadata with default values.
Exception type reserved for missing or invalid metadata.
The
MetaDataRepository uses implementations of this interface
to load and store metadata.Filters metadata resources.
Information about a metadata resource.
Comparator that keeps metadatas in inheritance order.
Iterator over metadata resources.
Metadata iterator that combines several iterators.
Mode constants used to track the initialization status of metadata.
Interface for metadata parsers.
Combines two internal
MetaDataFactory instances -- one for
metadata, one for mappings -- into a single MetaDataFactory facade.Collection of generic utility functions for extracting persistence related
metadata from user specified metadata available in various source
environment.
Repository of and factory for persistent metadata.
A
PluginValue that interacts with the CacheMarshaller
to cache the metadata repository between executions.Interface for meta data serializers.
Set of metadata tags used in JPA.
Tool for generating default metadata.
Run flags.
Executes the metadata tool on the specified files.
Attribute Category makes a finer distinction over PersistentAttributeType declared in
Attribute.PersistentAttributeType such as id, version, lob or enum.Compares attribute by their category and within the same category by name.
Adapts JPA Metamodel to OpenJPA meta-data repository.
Callback adapter that invokes a callback method via reflection.
A query that is executed by a user-defined method.
Denotes MIN(e) Expression.
Denotes (e1 - e2) Expression.
Defines lock levels used for MixedLockManager.
Helper methods translate between JPA-defined lock mode and OpenJPA
internal lock levels.
Mixed lock manager implements both optimistic and pessimistic locking
semantics in parallel to the JPA 2.0 specification.
Class loader type that can be configured to delegate to multiple
internal class loaders.
Uses multiple version numbers spanning multiple columns for optimistic
versioning.
A simple
ClassResolver that uses multiple class loaders to
resolve classes.A LogFactory implementation to pass events through multiple
LogFactory implementations(such as log4j and LogPanelFactory).
A parameter
Dictionary for MySQL.
Name sets track what names have been taken, ignoring case.
Uses a timestamp for optimistic versioning with nanosecond
precision.
JDBCSeq implementation that uses a database sequence
to generate numbers.Denotes NEW fully.qualified.class.name(arg1, arg2,...)
Strategy for classes that aren't mapped.
No-op Discriminator strategy.
An unmapped field.
A lock manager that does not perform any locking.
A log factory implementation that does not do any logging, as
quickly as possible.
No-op log.
No-op mapping defaults.
No-op metadata I/O to prevent attempts to load other classes.
Does nothing when an orphaned key is discovered.
Clears all mapping information from classes and installs none strategies.
No-op version strategy.
Metadata about a persistence-aware type.
Indicates that the annotated relation is not entirely polymorphic.
Nonpolymorphic settings.
Unique query returned multipl results.
Exception type thrown when a query was configured to return
a single result, and multiple results were found.
Implementation of
CacheMarshaller that does nothing.Unique query returned no results.
Exception type thrown when a query was configured to return
a single result, and no result was found.
Static utility class used for operating on string based identifiers.
Denotes (e1 !
Exception type thrown when attempting a transactional operation without
an active transaction.
A literal null value in a filter.
OPENJPA-1794
An aggregate unary operation that can indicate whether a null value from the data store
should be returned as null.
An in-memory representation of a nullif expression
NullIf expression.
Uses a version number for optimistic versioning.
In-memory form of data in datastore backing a single persistent object.
Exception type reserved for conflicts with existing objects.
An interface to create objects that are used by result processing.
A parameterized interface defines the protocol for converting
managed persistence
instances or a persistent domain model into a form suitable for transport to a language-neutral
client such as an web browser.Identity type appropriate for object primary key fields and shared
id classes.
Class mapping for embedded object id fields.
State manager used to access state of embedded object id primary key fields.
Handler for embedded object id fields.
Exception type reserved for failed object lookups.
An object
Value.Allows facades to control the particulars of persistence operations
through callbacks.
Defines the properties necessary to configure runtime properties and
connect to a data source.
Implementation of the
OpenJPAConfiguration interface.OpenJPA-specific extension to JPA 2.0 Criteria Query Builder API.
OpenJPA-specific extension to JPA 2.0 Criteria Query API.
Processes Application model classes and enhances them by running OpenJPA
Enhancer tool.
Interface implemented by OpenJPA entity managers.
Interface implemented by OpenJPA entity manager factories.
Extension of the JPA
EntityTransaction interface.An interface to define conversion of a facade based enum to a kernel integer constant.
Exception type for all OpenJPA exceptions.
Identity class extended by built-in OpenJPA identity objects.
Static helper methods for JPA users.
Adds datastore based extension to ProductDerivation.
Interface implemented by OpenJPA queries.
Builds dynamic query
Represents a savepoint where operations afterwards can be rolled
back and restored to this point
Executes the schema generation via the OpenJPA MappingTool.
Executes the SQL generation via the OpenJPA MappingTool.
Interface implemented by OpenJPA state managers.
Enables in place enhancement for entities listed or found by scanning in test classpath.
Processes Application model test classes and enhances them by running OpenJPA
Enhancer tool.
This class contains version information for OpenJPA.
Compute validity based on whether or not the cached data is from the same
version of Kodo as the current install.
Update manager that writes SQL in object-level operation order.
A path resulting from KEY() or VALUE() operation on an existing path.
Exception type for optimistic concurrency violations.
Optimistic concurrency violation.
A specialization of the
Properties map type with the added
abilities to read application options from the command line and to
use bean patterns to set an object's properties via command-line the
stored mappings.Dictionary for Oracle.
Order a field.
Denotes an item of ORDER BY clause.
Instances of this interface can be used as orderBy arguments.
Surrogate order column.
Defines a map that allows bidirectional lookup between key and values
and retains and provides access to an ordering.
Defines an iterator that operates over an ordered container.
Defines a map that maintains order and allows both forward and backward
iteration through that order.
A Map with predictable iteration order.
Defines an iterator that operates over an ordered
Map.Merged result object provider specialization that extracts ordering
values from results for comparison.
Perform an action when OpenJPA detects an orphaned key in the database.
Denotes (e1 OR e2) predicate.
Implementation of the
ManagedRuntime interface that listens
for an OSGi service with interface jakarta.transaction.TransactionManager
to create a TransactionManager for controlling transactions.Object provider implementation that fetches one page of results at a
a time as it scrolls.
A parameter in a filter.
Expression state.
A query parameter.
Denotes a parameter in a query.
A user-defined parameter of a query.
A template that allows parameter substitutions.
Signifies that a lexical error occurred when parsing the JPQL statement.
Exception type for parse errors.
A partitioned data cache maintains a set of partitions that are DataCache themselves.
A path represents a traversal into fields of a candidate object.
Interface for operations over objects reached via paths
Operator that combines two components to form a path.
Transformer that makes persistent classes implement the
PersistenceCapable interface at runtime.Holds data about a single persistence capable instance.
Generates
PCData instances which avoid primitive wrappers
to optimize memory use and performance at the cost of slightly higher
startup time.Dynamic
PCDatas generated will implement this interface
to simplify initialization.Default
PCData implementation.Bytecode enhancer used to enhance persistent classes from metadata.
Plugin interface for additional enhancement.
Run flags.
Java agent that makes persistent classes work with OpenJPA at runtime.
Executes the enhancer on the specified files.
A path represents a traversal into fields of a candidate object.
Expression state.
Tracks registered persistence-capable classes.
Listener for persistent class registration events.
Variant of
ResultObjectProvider that populates a
OpenJPAStateManager object in an application-defined manner.Base class for all lifecycle states.
Validates that a given type meets the JPA contract, plus a few
OpenJPA-specific additions for subclassing / redefinition:
must have an accessible no-args constructor
must be a public or protected class
must not be final
must not extend an enhanced class
all persistent data represented by accessible setter/getter
methods (persistent properties)
if versioning is to be used, exactly one persistent property for
the numeric version data
When using property access, the backing field for a persistent
property must be:
private
set only in the designated setter,
in the constructor, or in
Object.clone(),
readObject(ObjectInputStream), or
Externalizable.readExternal(ObjectInput).
read only in the designated getter and the
constructor.
Used to discover/resolve JPA providers in an OSGi environment.
The interface that persistent instances will implement.
General persistence exception.
Converts from OpenJPA to persistence exception types.
Supplies default mapping information in accordance with JPA spec.
MetaDataFactory for JPA mapping information.JPA-based metadata defaults.
MetaDataFactory for JPA metadata.Sets JPA specification defaults and parses JPA specification XML files.
SAX handler capable of parsing an JPA persistence.xml file.
Custom configuration provider.
Bootstrapping class that allows the creation of a stand-alone
EntityManager.Set of field persistence strategies used in JPA.
Implementation of the
PersistenceUnitInfo interface used by OpenJPA
when parsing persistence configuration information.Simple class resolver built around the persistence unit loader.
Metadata annotation for a persistent field.
Metadata annotation for a persistent collection field.
Metadata annotation for a persistent map field.
Listener for newly-persisted instances.
Pessimistic concurrency violation.
Lock manager that uses exclusive database locks.
A list of plugins.
A plugin
Value consisting of plugin name and properties.Denotes (e1 + e2) Expression.
Lifecycle state.
Dictionary for Pointbase Embedded.
Dictionary for PostgreSQL.
Connection wrapper to work around the postgres empty result set bug.
Statement wrapper to work around the postgres empty result set bug.
Interface used to define compound predicates.
Interface for constructing where-clause and having-clause conditions.
A prepared query associates a compiled query to a parsed state that
can be executed possibly with more efficiency.
A cache to create and maintain
prepared queries.A structure to describe the strength and reason for excluding a query from the cache.
An implementation of the cache of
prepared queries.Strong exclusion.
Weak exclusion.
A JMX-specific instrument for the query cache
Implements
PreparedQuery for SQL queries.A Select-oriented Result Object Provider whose Select has been executed
outside its own scope.
A executor for Prepared SQL Query.
Executor of a prepared query uses the QueryExpressions of the original query
available via the PreparedQuery.
Manages prepared statement execution.
Basic prepared statement manager implementation.
Represents a table primary key.
Primary table row that tracks foreign keys and auto-inc columns.
Direct mapping from a primitive value to a column.
Specialized RuntimException thrown by JEST commands.
Hooks for deriving products with additional functionality.
Derives configuration for Slice.
Utilities for running product derivations.
Represents configuration properties in HTML.
Simple
ReverseCustomizer that uses a properties file to
to allow customization of basic class and field properties.A factory for a specific type of objects registered by a key.
Utility methods for managing proxies.
Interface implemented by all proxy types to allow setting and nulling
of their owning instance.
Interface implemented by all generated custom types, which use JavaBean
conventions for copying state.
Interface implemented by all generated proxies on
Calendar
types.Interface implemented by all proxy collection types.
Utility methods used by collection proxies.
Marker interface for a proxied iterator.
Marker interface for a proxied list iterator.
Interface implemented by all generated proxies on
Date
types.Manager for copying and proxying second class objects.
Default implementation of the
ProxyManager interface.Interface implemented by proxies on
Map types.Utility methods used by map proxies.
Marker interface for a proxy entry set.
This class extends DBIdentifier to provide support for qualified identifiers
such as schema qualified tables and table qualified columns.
OpenJPA query interface.
Factory interface for query definition objects
The factory for QueryDefinition.
Interface that must be implemented by any level 2 query cache
used by OpenJPA.
Interface for providing instrumented data cache metrics and operations.
A JMX-specific instrument for the query cache
Simple MBean interface for providing instrumented query cache metrics
and operations.
A
StoreQuery implementation that caches the OIDs involved in
the query, and can determine whether or not the query has been dirtied.Result list implementation for a cached query result.
A cache of compiled queries.
A query execution context.
Interface for construction of query definitions
Implements QueryDefinition.
Exception indicating that a query timeout occurred.
Struct to hold the state of a parsed expression query.
Struct to hold the state of a query expressions instance.
Constants for determining when to flush before queries.
Standard query hint keys.
Implementation of the
Query interface.Implementation of
Query interface.Struct of compiled query properties.
Result object provider that packs results before returning them.
This class stores information about a particular invocation of
a query.
Constants and utilities for query languages.
Holds metadata about named queries.
Query operation constants.
The possible operations that a query can perform.
A query result.
Query result cache.
Implements Query result cache via delegation to QueryCache.
A callabck is used when a query results in multiple non-identical result sets.
Mapping of a query result set to scalar and/or persistence-capable
object-level values.
Records query execution statistics.
A default implementation.
A do-nothing implementation.
Policy to select one or more of the physical databases referred as
slice in which a given query will be executed.
Query timeout violation.
Random-access result list implementation.
Denotes a range used by e1 BETWEEN x AND y operation.
Prevents a view of a given range of indices from the delegate
result object provider.
Represents a raw SQL string for passing to
Row.setObject.Marks a field read-only.
Custom Attribute to mark that this class already got redefined.
Helper methods for managed types that use method redefinition for field
tracking.
A reentrant lock that lets a child to work with the parent's lock.
Map in which the key, value, or both may be weak/soft references.
A set whose values may be stored as weak or soft references.
A
Map implementation that allows mappings to be
removed by the garbage collector and matches keys and values based
on == not equals().A
Map implementation that allows mappings to be
removed by the garbage collector.A
Map type that can hold its keys, values, or both with
weak or soft references.Exception type reserved for violations of integrity constraints.
Annotates a getter method or field so
reflection
utility to control whether the annotated member is recorded during scanning
for bean-style method or field.Implementation of the
PersistenceCapable interface that can handle
the persistence-capable contract for instances that were not enhanced
before class load time.Reflection utilities used to support and augment enhancement.
Attempts to install using the given mapping information.
Implementation of the
ManagedRuntime interface that uses
the TransactionSynchronizationRegistry interface (new in JTA 1.1)
to create a TransactionManager facade for controlling transactions.Maps a relation to a collection of other objects using an inverse
foreign key in the related object table.
Maps a collection of related objects through an association table.
Mapping for a single-valued relation to another entity.
Mapping for a map whose keys are relations to other persistent objects
and whose values are controlled by a
ValueHandler.Callback to store a relation after the object id has been assigned.
Uses an inverse foreign key in the table of the map value to determine
map values.
Uses an association table to hold map values.
Mapping for a map whose keys and values are both relations to other
persistent objects.
Helper methods for relation mappings.
Maps a relation to a set of other objects using an inverse
foreign key in the related object table.
Maps a set of related objects through an association table.
Event type to hold the IDs of additions, updates, and
deletes.
Manager that can be used to track and notify
RemoteCommitListeners on remote commit events.An entity that wishes to be notified when Brokers
associated with remote BrokerFactories commit.
An entity that is responsible for communicating commit
notification to other
RemoteCommitEventManagers.Value type used to represent a
RemoteCommitProvider.Policy to select one or more of the physical databases referred as
slice in which a given persistent instance will be persisted.
Implements a default replication policy to replicate the given
instance across all available slices.
A
SQLException that contains information about
the Statement SQL that caused the exception.Utility to test validity of identifier or parameter name.
Defines an iterator that can be reset back to an initial state.
Defines a list iterator that can be reset back to an initial state.
A Resolver is used to resolve listeners and class or entity names
that appear in a query.
Iterator over a given metadata resource.
State restore constants.
The possible settings for the restore behavior after transaction rollback
of an
OpenJPAEntityManager.A result from the execution of a query or stored procedure.
List interface that represents a potentially lazy ResultList instantiation.
Wrapper iterator that will return false for
hasNext() if
the owning ResultList has been closed.Interface that allows lazy/custom instantiation of input objects.
Iterator wrapped around a
ResultObjectProvider.Helper class to pack results into the result class set on the query.
Base
Result implementation wrapped around a result set.Type of result set to use.
Describes the shape of a query result.
Packs result by delegation to a ResultShape.
Plugin in interface to customize the output of the
ReverseMappingTool.Reverse-maps a schema into class mappings and the associated java
code.
Holder for run flags.
Executes the
ReverseMappingTool on the specified XML files.Rollback occurred on attempt to commit.
Denotes root domain instance representing a persistent type.
Logical representation of a table row for insert/update/delete.
Basic
Row implementation.Manages rows during an insert/update/delete process.
Manages SQL rows during an insert/update/delete process.
Interface used by many facade helpers to translate exceptions.
Installer that attempts to use the given mapping information, and
fails if it does not work.
Possible values for the
openjpa.RuntimeUnenhancedClasses
configuration setting.FieldManager type used to store information for rollback.
A manager for handling savepoints.
Represents a database schema.
Factory for
SchemaGroups.The SchemaGenerator creates
Schemas matching the current
database.An event corresponding to the generation of a schema object.
A listener for a potentially lengthy schema generation process.
Represents a grouping of schemas used in a database.
Interface class for parers that read schema information.
Helper class to deal with schemas.
Interface for schema serializers.
The SchemaTool is used to manage the database schema.
Run flags.
Executes the
SchemaTool on the specified XML schema definition
files.Secondary table row that tracks foreign keys to auto-inc columns.
Abstraction of a SQL SELECT statement.
Turns parsed queries into selects.
Interface for configuring and executing a SQL select.
Standard
Select implementation.A
Result implementation wrapped around this select.Helper class to track selected columns, with fast contains method.
SelectItem instances are used in specifying the query's select list.
Abstract provider implementation wrapped around a
Select.Internal OpenJPA sequence interface.
Represents a database sequence.
Specialization of sequence metadata for ORM.
Metadata about a named sequence.
Allow facades to supply adapters from a spec sequence type to the
OpenJPA sequence type.
Value type used to represent a sequence.
Helper class to serialize and deserialize persistent objects,
subtituting oids into the serialized stream and subtituting the persistent
objects back during deserialization.
Object input stream that replaces oids with their objects.
Object output stream that replaces persistent objects with their oids.
Utility classes to locate services, as defined in the Jar File Specification.
OpenJPAId subclass appropriate for short fields.An in-memory representation of a simple case expression
Simple case expression.
Non-pooling driver data source.
Base node implementation for all JPQL nodes.
Allows for simple regex style testing of strings.
An almost stateless
ResultList designed for use with result
object providers backed by efficient random-access data structures, such
as the ListResultObjectProvider.Single-JVM-only implementation of
RemoteCommitProvider
that listens for object modifications and propagates those changes
to other SingleJVMRemoteCommitProviders in the same JVM.A sized value.
A
Map type that maintains a maximum size, automatically
removing entries when the maximum is exceeded.Denotes SIZE(e) Expression.
LogFactory implementation that delegates to the SLF4J framework.Adapts a Log4J logger to the
Log
interface.Represents a database slice of immutable logical name, a configuration and
status.
Utility methods to determine the target slices for a persistence capable
instance by calling back to user-specified distribution policy.
Holder of slice names where a persistent instance is stored.
A helper to determine the slice identifier of an instance.
A specialized JDBCStoreManager for a slice.
A thread to execute operation against each database slice.
Specialization of the
RandomAccessResultList that only maintains
soft references to instantiated objects.Dictionary for SolidDB database.
Defines a map that allows bidirectional lookup between key and values
and retains both keys and values in sorted order.
Extracts persistent metadata information by analyzing available annotation
in *.java source files.
A utility to help writing Java Source code dynamically.
Interface that can optionally be implemented by metadata
to include the source file from which the metadata was originally parsed.
Utility class for performing common operations on
SourceTrackers.An immutable representation of a Specification supported by OpenJPA.
A plug-in for Specification that enforces certain overwriting rules.
Buffer for SQL statements that can be used to create
java.sql.PreparedStatements.
Simple listener which embeds its SQL argument into the query.
Parses XML content of SQL Error State codes to populate error codes for
a given Database Dictionary.
Helper class for converting a
SQLException into
the appropriate OpenJPA type.Deprecated.
Use
SQLEmbed directlyFactory for SQL constructs.
Default factory for SQL abstraction constructs.
Converts single-line SQL strings into nicely-formatted
multi-line, indented statements.
Dictionary for Microsoft SQL Server.
A SQL query.
Executes the filter as a SQL query.
Deprecated.
Use
SQLEmbed directlySquare root.
Denotes SQRT(e) Expression.
Uses a state image to determine whether concurrency violations take place.
Row implementation we use to pass to versionable mappings so they
can set up the where conditions we need to add to update statements.
Internal state manager for managed instances.
Implementation of the
OpenJPAStateManager interface for use
with this runtime.Represents the L2 cache over the data store.
Implements the L2 cache over the data store via delegation to DataCache.
Base class for strategies that are stored as a collection, even if
their field value is something else.
Represents a set of managed objects and their environment.
Holds metadata about a Database Stored Procedure.
An enumeration on type of parameter for a Stored Procedure.
Executes a stored procedure.
Implements Store Procedure based query for JPA facade.
Base exception for data store errors.
Repository of store-specific facade classes.
Listener for when persistent instances are stored to the database.
Interface to be implemented by data store mechanisms to interact with
this runtime.
Component that executes queries against the datastore.
An executor provides a uniform interface to the mechanism for executing
either an in-memory or datastore query.
A query result range.
Interface implemented by all mapping strategies.
Mapping strategy.
Installs mapping strategies.
Deprecated.
Use
matches() instead.Utilities for calculating string distance.
Direct mapping from a string value to a column.
OpenJPAId subclass appropriate for String fields.Returns the number of characters in a string.
A comma-separated list of string values.
A string
Value.Determines how to eager-fetch subclass data.
Discriminator strategy that outer joins to all possible subclass tables
to determine the class of an instance.
A subquery.
Query value representing a subquery.
Instances of this interface can be used as subqueries.
Take a substring of a string.
Denotes SUBSTR(a,i1,i2) Expression.
Filters metadata iteration based on resource name suffix.
Denotes SUM(e) Expression.
ManagedRuntime implementation for SunONE.Discriminator strategy that delegates to superclass discriminator.
Version strategy that delegates to the suerpclass version.
Dictionary for Sybase.
Connection wrapper to cache the
Connection.getCatalog() result,
which takes a very long time with the Sybase Connection (and
which we frequently invoke).Represents a database table.
JDBCSeq implementation that uses a database table
for sequence number generation.Helper struct to hold status information.
Factory that uses an XML schema definition stored in a database table
to record the system schema.
A fetch configuration that is aware of special hint to narrow its operation on
subset of slices.
TCP-based implementation of
RemoteCommitProvider that
listens for object modifications and propagates those changes to
other RemoteCommitProviders over TCP sockets.ClassLoader implementation that allows classes to be temporarily
loaded and then thrown away.
A simplistic implementation of a
Seq used
to provide datastore ids.Denotes (e1*e2) Expression.
Helper base class attempts to return java.sql.Timestamp object with
nanosecond precision.
Uses a timestamp for optimistic versioning.
Describes the input token stream.
Token Manager Error.
Reads from an input stream and writes to an output stream after replacing matched tokens
by their counterpart.
Lower-cases a string.
Upper-cases a string.
A transactional event.
Manager that can be used to track and notify transaction listeners
of transaction-related events.
Interface for listening to all
TransactionEvents.Transaction required.
OpenJPA optimized TraversableResolver Default implementation/behavior asks all discovered providers -
jakarta.persistence.Persistence.getPersistenceUtil().isLoaded( traversableObject, traversableProperty.getName());
Red-Black tree-based implementation of BidiMap where all objects added
implement the
Comparable interface.Returns the number of characters in a string.
Denotes TRIM(e1,x) Expression.
Used to specify the trimming of strings
A factory for tuples such that all instances created by a factory instance share the same TupleElements
to save memory consumption.
Tuple holds a set of values corresponding to a set of
TupleElement.Indicates the persistent type of a field, if different than the
declared type.
A cache distribution policy based on the type of the managed objects.
A specialization of the
Properties map type with added
convenience methods to retrieve and set options as primitive values.Denotes TYPE(e) Expression.
A type literal value.
Persistent Type according to JPA 2.0.
Basic non-relational types of a persistent attribute such as
long or
java.util.Date.An embedded, not independently identifiable type.
An entity type that is independently identifiable.
Represents an abstract persistent type that has a persistent identity.
A abstract, independently identifiable persistent type.
A pseudo managed type used to represent keys of a java.util.Map as a
pseudo attribute.
An event indicating that instances of given persistent types have
been modified.
An entity that wishes to be notified when types change.
Enumeration of operator that operates on a single expression to generate
a predicate.
Enumeration of operator that operates on a single expression to generate
another expression.
Denotes (-e) Expression.
Enumeration of Operator that operate on a single expression.
SQL UNION.
A callback used to create the selects in a SQL union.
Represents a unique constraint.
Unique constraint definition.
Aggregates individual single query results from different databases.
Marker interface for collections, maps and iterators that are unmodifiable.
Decorates another
Collection to ensure it can't be altered.Decorates a map entry
Set to ensure it can't be altered.Decorates an iterator such that it cannot be modified.
Decorates another
List to ensure it can't be altered.Decorates a list iterator such that it cannot be modified.
A
Map.Entry that throws
UnsupportedOperationException when setValue is called.Decorates another
OrderedMap to ensure it can't be altered.Decorates an ordered map iterator such that it cannot be modified.
Decorates another
Set to ensure it can't be altered.Exception type for attempts to perform unsupported operations.
Handler for unknown persistence-capable object fields that stores
stringified oids.
Action to take when a field's value is changed.
This interface is used to customize the way that updates are made to
database records.
Strategies for persistent value updates.
Denotes UPPER(e) Expression.
Iterator over the metadata resource represented by a URL.
Base exception type for user errors.
UUID value generator.
Sequence for generating 32-character hex UUID strings.
Sequence for generating 16-character UUID strings.
Sequence for generating 32-character hex Type 4 UUID strings.
Sequence for generating 16-character UUID strings.
A Value represents any non-operator in a query filter, including
constants, variables, and object fields.
An in-memory representation of a
Value.ErrorHandler implementation which overrides the default
behavior of ignoring parse errors to throw a
SAXException instead.An extension of LifecycleEventManager which adds validation capabilities for
specific lifecycle events.
Validation helper routines and wrappers to remove runtime dependencies
on the Bean Valdiation APIs or a implementation.
Basic validation interface which defines the contract for
event based validation.
Interface for any non-operator in a query filter, including
constants, variables, and object fields.
A configuration value.
Denotes VALUE(e) Expression.
Maps a value to a relational schema.
Components can listen on
Value objects for changes directly.Maps metadata-given values to classes.
Specialization of value metadata for relational databases.
Standalone
ValueMapping implementation.Information about the mapping from a field value to the schema, in
raw form.
Holds metadata on a value; this could be a field value, key value, or
element value.
Default
ValueMetaData implementation.Strategies for persistent value generation.
Specialization of the
TableJDBCSeq that maintains multiple
sequence counts.A expression that holds an array of Expressions.
Handles optimistic lock versioning for a class.
Surrogate version column.
Allows the specification of multiple version columns for complex versioning.
LockManager implementation that provides support
for version checking and version updating when locks are acquired.Information about the mapping from a version indicator to the schema, in
raw form.
Handles optimistic lock versioning for a class.
Version mapping strategy.
Mapping for subclasses that join to their superclass table.
An element of query that is convertible to a JPQL String given a aliasing
scheme.
ManagedRuntime implementation that allows synchronization with a
WebSphere managed transaction.WASRegistryManagedRuntime provides WebSphere specific extensions to
RegistryManagedRuntime.Denotes WHEN ...
Value produced by a when_clause of a case expression.
Value produced by a when_clause of a case expression.
Deprecated.
Use
matches() instead.ResultList implementation that uses a forward-scrolling window of results.
ManagedRuntime implementation that directly accesses the
transaction manager via WebLogic Server helper classes.Identifiable exception type which wraps an internal runtime exception.
Embedded mapping information.
Extended join column.
Allows the specification of multiple columns for compound joins.
Allows override of complex embedded or superclass mappings.
Allows override of complex embedded or superclass mappings.
Configuration implementation for the XML file store.
The XMLFactory produces validating and non-validating DOM level 2
and SAX level 2 parsers and XSL transformers through JAXP.
Contains metadata about an xml element or attribute
Stores
ObjectData objects by serializing a collection
of them into and out of an XML file.Marshals a root instance and its persistent closure as an XML element.
Describe metadata about an xml type.
Custom SAX parser used by the system to quickly parse metadata files.
Abstract base type for serlializers that transfer groups of objects
to XML.
Custom SAX parser used by the system to parse persistence mapping files.
Serializes persistence mapping to XML.
Custom SAX parser used by the system to quickly parse persistence
metadata files.
Serializes persistence metadata back to XML.
Custom SAX parser used to parse
Schema objects.Used to hold unique constraint info before it is resolved.
Serializes
Schemas to XML matching the document
type definition defined by the XMLSchemaParser.Represents a store of object data encoded in XML.
Store manager to a back-end consisting of XML files.
Base class for xml value handlers.
Custom non-validating SAX parser which can be used to get the version and
schema location attributes from the root node.
The XMLWriter is a writer type for pretty-printing XML.
Gets multiple Result Object Providers each with different mapping.
Extended secondary table.
Allows the specification of multiple secondary tables.
Extended table.
Iterator over all metadata resources in a given zip file.
Iterator over all metadata resources in a given zip input stream.
matches()instead.