All Classes and Interfaces
Class
Description
The ABS function removes the minus sign from a specified argument and returns the absolute
value, which is always a positive number or zero.
This
AbsExpressionFactory creates a new AbsExpression when the portion of the
query to parse starts with ABS.Purpose: Maps an attribute or some other property to the corresponding
database field type.
Define an embedded collection of objects.
AbstractCompositeDirectCollectionMapping consolidates the behavior of mappings that
map collections of "native" data objects (e.g.Chunks of data from non-relational data sources can have an
embedded component objects.
Conditional expressions are composed of other conditional expressions, comparison operations,
logical operations, path expressions that evaluate to boolean values, boolean literals, and
boolean input parameters.
Purpose: Allows customization of how an object is cloned.
Purpose: Maps an attribute to the corresponding database field type.
This
Expression takes care of parsing an expression that encapsulates two expressions
separated by a comma.The abstract implementation of
EclipseLinkExpressionVisitor.This visitor calculates the type of an input parameter.
This validator is responsible to gather the problems found in a JPQL query by validating the
content to make sure it is semantically valid for EclipseLink.
This visitor retrieves the clause owning the visited
Expression.This
ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given Expression.This
EclipseLinkExpressionVisitor traverses up the hierarchy.This expression handles parsing the identifier followed by an expression encapsulated within
parenthesis.
Base class for entity resource.
This is the abstract definition of all the parts used to create the tree hierarchy representing
the parsed JPQL query.
The abstract definition of
ExpressionVisitor, which implements all the methods but does
nothing.The FROM clause of a query defines the domain of the query by declaring identification
variables.
The base validator responsible to gather the problems found in a JPQL query by validating it
against the provided JPQL grammar.
This validate is responsible to validate the collection of
Expressions:
Making sure they are all separated by a comma or by a space (depending on which one is
required);
Making sure it does not end with a comma;
There is no empty expression between two commas.
AbstractGrammarValidator.AbstractDoubleEncapsulatedExpressionHelper<T extends AbstractDoubleEncapsulatedExpression>
AbstractGrammarValidator.AbstractEncapsulatedExpressionHelper<T extends AbstractEncapsulatedExpression>
The root helper that validates any
AbstractEncapsulatedExpression.AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper<T extends AbstractSingleEncapsulatedExpression>
The abstract implementation of
AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper which
implements some of the methods since the behavior is the same for all subclasses of
AbstractSingleEncapsulatedExpression.AbstractGrammarValidator.AbstractTripleEncapsulatedExpressionHelper<T extends AbstractTripleEncapsulatedExpression>
This visitor retrieves the
CollectionExpression if it is visited.This validator validates a
CollectionExpression by making sure each item is separated
by a comma.This validator validates a
CollectionExpression by making sure each item is not
separated by a comma.This visitor checks to see if the visited expression is
NullExpression.Abstract class for SDO helper delegators.
The abstract definition of a
JPQLGrammar.This factory is responsible to return the right literal expression.
PUBLIC: Description: This node null policy allows for the handling of
various representations of null in XML documents.
An ordering clause allows the objects or values that are returned by the query to be ordered.
An identification variable followed by the navigation operator (.) and a state field or
association field is a path expression.
Base class for persistent unit resources.
Base class for query resource.
Base class for all resources.
An abstract schema name designates the abstract schema type over which the query ranges.
The query BNF for an abstract schema name.
This
AbstractSchemaNameFactory creates a new AbstractSchemaName.The SELECT clause denotes the query result.
A query is an operation that retrieves data from one or more tables or views.
The base validator responsible to gather the problems found in a JPQL query by validating the
content to make sure it is semantically valid, i.e.
This visitor is meant to retrieve an
CollectionValuedPathExpression if the visited
Expression is that object.This visitor compares the left and right expressions of a comparison expression and gathers
information about those expressions if they are an identification variable or a path expression.
This enumeration allows
AbstractSemanticValidator.validateStateFieldPathExpression(StateFieldPathExpression, PathType) to validate the type of the mapping and to make sure it
is allowed based on its location.This visitor is meant to retrieve an
AbstractSemanticValidator.StateFieldPathExpressionVisitor if the visited
Expression is that object.Abstract Serializer class.
Represents the abstract log that implements all the generic logging functions.
This expression handles parsing a JPQL identifier followed by an expression encapsulated within
parenthesis.
Base class for all single result query resources.
Purpose: Abstract Synchronization Listener class
Description: This abstract class is paired with the
AbstractTransactionController class.
Purpose: Abstract implementation of an ExternalTransactionController.
Purpose: A transformation mapping is used for a specialized translation between how
a value is represented in Java and its representation on the databae.
This
ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given Expression.This
ExpressionVisitor traverses up the hierarchy.This
Expression takes care of parsing an expression that encapsulates three expressions
separated by a comma.The abstract definition of a validator, which provides helper methods and visitors.
This visitor is responsible to traverse the children of a
CollectionExpression in
order to properly validate the Expression.This visitor is responsible to traverse the parent hierarchy and to skip
SubExpression
if it's a parent.This visitor gathers the children of a
CollectionExpression or a single visited
Expression.This visitor validates any
Expression by checking its BNF against some BNFs.This visitor retrieves the clause owning the visited
Expression.This visitor retrieves the statement owning the visited
Expression.This visitor retrieves the statement owning the visited
Expression.JPA scripting API implementation.
Purpose: Provides Microsoft Access specific behavior.
An additional criteria can be specified at the Entity or MappedSuperclass
level.
JPA scripting API implementation.
One of the four binary operators.
Purpose: Define the Public interface for the Aggregate Change Record.
Purpose: Define the Public interface for the Aggregate Collection Change Record.
Purpose: The aggregate collection mapping is used to represent the aggregate relationship between a single
source object and a collection of target objects.
The query BNF for an aggregate expression.
In the SELECT clause the result of a query may be the result of an aggregate function
applied to a path expression.
Purpose: Two objects can be considered to be related by aggregation if there is a strict
1:1 relationship between the objects.
Purpose:Two objects can be considered to be related by aggregation if there is a strict
1:1 relationship between the objects.
Purpose: An implementation of the OptimisticLockingPolicy interface.
An ALL conditional expression is a predicate that is
true if the comparison
operation is true for all values in the result of the subquery or the result of the
subquery is empty.The query BNF for an all or any expression.
This
AllOrAnyExpressionFactory creates a new AllOrAnyExpression when the portion
of the query to parse starts with ALL, ANY or SOME.
The AND logical operator chains multiple criteria together.
This
AndExpression creates a new AdditionExpression when the portion of the query
to parse starts with AND.Purpose:Provide a class which is responsible for returning Annotations
from AnnotatedElements.
Purpose:The purpose of this class is to act as a dynamic proxy that
allows JDK Annotation method calls to be made on a non Annotation object.
INTERNAL:
This visitor allows a subclass to simply override
AnonymousExpressionVisitor.visit(Expression) and perform the
same task for all visited expressions.INTERNAL:
INTERNAL:
This class using WLS classed to get unique application ID.
This class provides a means for the user to return application-specific
information, such as the application name, which will be used when the
logic in SDOHelperContext fails.
Provides an abstraction to deal with various kinds of URLs that can
be returned by
PersistenceUnitInfo.getPersistenceUnitRootUrl()This interface should be implemented by users that want to provide a custom way
of dealing with archives that contain persistence units.
This expression represents an arithmetic expression, which means the first and second expressions
are aggregated with an arithmetic sign.
The query BNF for an arithmetic expression.
This
ExpressionFactory creates a new expression when the portion of the query to parse
starts with an arithmetic identifier.This expression simply adds a plus or minus sign to the arithmetic primary expression.
The query BNF for an arithmetic factor expression.
The query BNF for an arithmetic primary expression.
The query BNF for an arithmetic term expression.
Array types are extended object-relational data-types supported by some databases.
JPA scripting API implementation.
Interface used by the
ArrayCollectionMappingHelper to interact
with the assorted array collection mappings.Helper class to consolidate all the heinous comparing
and merging code for the Array collection mappings.
An
ArrayIterator provides a Iterator for an array of objects.Purpose:
In an object-relational data model, structures can contain "Arrays" or collections of other data-types.
Purpose:Wraps an immutable value for a past time.
An
AS OF clause is part of a flashback query, which provides ways to view
past states of database objects, or to return database objects to a previous state, without using
traditional point-in-time recovery.The query BNF for the
AS OF clause.This
AsOfClauseFactory creates a new AsOfClause when the portion of the JPQL
query to parse starts with AS OF.Purpose:Wraps an immutable value for a past time, represented as a
database system change number.
An utility class that provides various checks and when the condition fails, then an
Assert.AssertException is thrown.The exception thrown when the condition is not met.
Purpose: Generic association object.
JPA scripting API implementation.
INTERNAL:
INTERNAL:
Purpose: This provides an abstract class for setting and retrieving
the attribute value for the mapping from an object.
PUBLIC:
An AttributeChangeTrackingPolicy allows change tracking at the attribute level of an
object by implementing ChangeTracker.
Purpose: An AttributeGroup represents a set of mappings and nested
AttributeGroups for relationship mappings for an entity type.
Represents an AttributeNode of an entity graph.
JPA scripting API implementation.
PUBLIC:
Purpose: Provides an empty implementation of AttributeTransformer.
TopLink Platform class which works with Attunity's Connect JDBC driver.
One of the aggregate functions.
This
AvgFunctionFactory creates a new AvgFunction when the portion of the query
to parse starts with AVG.This wraps another
Expression that was correctly parsed by it is located in an invalid
location within the JPQL query.The query BNF used for an expression that is invalid.
This
BadExpressionFactory creates a new BadExpression when the portion of the
query to parse is malformed.This visitor traverses the parsed tree and retrieves the
IdentificationVariable
defined in the base range variable declaration for the top-level statement if and only if the
query is a DELETE or UPDATE query.JPA scripting API implementation.
Deprecated.
Deprecated.
A BatchFetch annotation can be used on any relationship mapping,
(OneToOne, ManyToOne, OneToMany, ManyToMany, ElementCollection, BasicCollection, BasicMap).
JPA scripting API implementation.
BatchFetchPolicy defines batch reading configuration.
Enum used with the BatchFetch annotation, or "eclipselink.batch.type" query hint.
Specify the use of batch writing to optimize transactions with multiple writes,
by default batch writing is not used.
Helper class.
BeanValidationException should be used to represent any exception that happens during Bean Validation in MOXy.
INTERNAL:
English ResourceBundle for BeanValidationException messages.
INTERNAL:
Asynchronously starts validation.xml file processing when created.
XJC Plugin for generation of JSR349 (Bean Validation) annotations.
Used in conditional expression to determine whether the result of an expression falls within an
inclusive range of values.
The query BNF for the between expression.
This
BetweenExpressionFactory creates a new BetweenExpression when the portion of
the query to parse starts with BETWEEN or NOT BETWEEN.Purpose: Provides a means to configure bidirectional relationship
maintenance for OXM mappings.
The query BNF for a boolean expression.
The query BNF for a boolean literal expression.
The query BNF for a boolean primary expression.
Purpose: Base class transport manager for broadcasting RCM protocols: JMS and Oc4jJGroups.
The Cache annotation is used to configure the EclipseLink object cache.
JPA scripting API implementation.
Cache coordination protocol persistence property values.
An enum that is used within the Cache annotation.
Allow a cache index to be define.
Purpose:
Define a secondary index on the cache.
JPA scripting API implementation.
Allow a set of cache indexes to be define on an Entity.
A CacheInterceptor can be set on an Entity and allows all EclipseLink cache
access to be intercepted by the developer provided interceptor.
JPA scripting API implementation.
Purpose: Define a class through which Cache access can be
intercepted.
PUBLIC:
A CacheInvalidationPolicy is used to set objects in TopLink's identity maps to be invalid
following given rules.
Options for how Entity instances should be shared within an EclipseLink Persistence Unit / ServerSession
The CacheKeyInterceptor allows a Cache Interceptor implementation to wrap the EclipseLink CacheKey.
Configures what type of Id value is used to store the object in the cache.
Purpose:
CachePolicy defines the cache configuration.
The CacheType enum is used with the Cache annotation for a persistent class.
Cache type persistence property values.
Cache usage hint values.
In-memory querying and conforming indirection policy.
Call defines the interface used primarily by EclipseLink queries
and query mechanisms to perform the necessary actions
(read, insert, update, delete) on the data store.
JPA scripting API implementation.
Define the foreign key defined by the relationship to cascade the delete on the database.
Cascade policy hint values.
BNF:
general_case_expression ::= CASE when_clause {when_clause}* ELSE scalar_expression END
or
BNF: simple_case_expression ::= CASE case_operand simple_when_clause {simple_when_clause}* ELSE scalar_expression ENDThe query BNF for a case expression.
This
CaseExpressionFactory creates a new CaseExpression when the portion of the
query to parse starts with CASE.The query BNF for the case operand specified in the case expression.
The CAST function cast value to a different type.
The query BNF for the CAST function.
This
CastExpressionFactory creates a new CastExpression when the portion of the
query to parse starts with CAST.Purpose: An implementation of the OptimisticLockingPolicy interface.
A ChangeListener is used to extend a PersistenceContext to react to database sent change
events.
Purpose: Define the base Change Record API.
A change summary is used to record changes to DataObjects,
allowing applications to efficiently and incrementally update back-end storage when required.
Purpose: Define an interface for any object that wishes to use attribute change tracking.
The ChangeTracking annotation is used to specify the
org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy
which computes changes sets for EclipseLink's UnitOfWork commit process.
JPA scripting API implementation.
An enum that is used within the ChangeTracking annotation.
Provide an interface to allow for custom character escaping behaviour.
Purpose: This class maintains information about a generated class and its corresponding interface
Purpose:
Abstract descriptor class for defining persistence information on a class.
A ClassExtractor allows for a user defined class indicator in place of
providing a discriminator column.
Purpose:
Abstract class to allow complex inheritance support.
Purpose: Allows a class name to be converted to and from a new instance of the class.
The class is used internally by the Portable JMX Framework to convert
model specific classes into Open Types so that the attributes of model class can
be exposed by MBeans.
The class is used internally by the Portable JMX Framework to convert
model specific classes into Open Types so that the attributes of model class can
be exposed by MBeans.
The class is used internally by the Portable JMX Framework to convert
model specific classes into Open Types so that the attributes of model class can
be exposed by MBeans.
The class is used internally by the Portable JMX Framework to convert
model specific classes into Open Types so that the attributes of model class can
be exposed by MBeans.
The class is used internally by the Portable JMX Framework to convert
model specific classes into Open Types so that the attributes of model class can
be exposed by MBeans.
Purpose: Acts as a client to the server session.
A CloneCopyPolicy is used to set an
org.eclipse.persistence.descriptors.copying.CloneCopyPolicy on an Entity.
Purpose: Allows a clone of an object to be created with a method that returns
the cloned object.
JPA scripting API implementation.
Pull together mutator state and behavior for subclasses.
A
CloneListIterator iterates over a copy of a list,
allowing for concurrent access to the original list.Used by
CloneListIterator to remove
elements from the original list; since the list iterator
does not have direct access to the original list.Purpose: Provides CloudScape DBMS specific behavior.
Description: Place holder for CMP specific information.
INTERNAL:
This is the interface used to encapsulate the the type of key class element
INTERNAL:
This class will be used when the keyClass is a primitive
A COALESCE expression returns
null if all its arguments evaluate to
null, and the value of the first non-null argument otherwise.The query BNF for a coalesce expression.
This
CoalesceExpressionFactory creates a new CoalesceExpression when the portion
of the query to parse starts with COALESCE.Purpose:This interface can be implemented and used in conjunction with SDOClassGenerator
to write the generated source as desired.
Purpose: Define a change event for collection types.
Purpose: This interface defines the API for the changeRecord that maintains the changes made to a collection attribute of
an object.
Purpose: Define an interface for any collection that wishes to use attribute change track.
A
CollectionExpression wraps many expression which they are separated by spaces
and/or commas.Purpose: Abstract class for relationship mappings which store collection of objects
An identification variable declared by a collection member declaration ranges over values of a
collection obtained by navigation using a path expression.
The query BNF for a collection member declaration expression.
This
CollectionMemberDeclarationFactory creates a new CollectionMemberDeclaration
when the portion of the query to parse starts with IN.This expression tests whether the designated value is a member of the collection specified by the
collection-valued path expression.
The query BNF for a collection member expression.
This
CollectionMemberExpressionFactory creates a new CollectionMemberExpression
when the portion of the query to parse starts with MEMBER, MEMBER OF, NOT
MEMBER or NOT MEMBER OF.JPARS 2.0 collection proxy interface.
Deprecated.
JPA scripting API implementation.
This utility class provides utility methods related to collections, iterators and arrays.
A
collection_valued_field is designated by the name of an association field in a
one-to-many or a many-to-many relationship or by the name of an element collection field.The query BNF for a collection-valued path expression.
Helper class used to create proxies for collections.
Makes the CollectionWrapper class available in our Dynamic JAXB context.
JPA scripting API implementation.
JPA scripting API implementation.
Purpose:
Concrete class to represent the ColumnResult structure as defined by
the EJB 3.0 Persistence specification.
Purpose: Provide an extendable framework class for a Command object
that can be remotely executed.
Purpose: Define a pluggable conversion interface that can be supplied
by the application
Purpose: Provide an interface that clients can use to invoke remote
commands on other EclipseLink instances, or on other applications that may want
to receive and process EclipseLink commands.
Purpose: Defines a pluggable interface for EclipseLink sessions and EclipseLink
applications to be able to be on the receiving end of EclipseLink command objects.
Commit order type persistence property values.
Purpose:This exception wraps all RMI or CORBA or IO exception that may occur.
INTERNAL:
English ResourceBundle for CommunicationException messages.
Only the values of like types are permitted to be compared.
The query BNF for a comparison expression.
This
ComparisonExpressionFactory creates a new ComparisonExpression when the
portion of the query to parse starts with <, >, <>, <=,
>= or =.Helper class for code that needs to be shared between AnnotationsProcessor,
MappingsGenerator, SchemaGenerator
Purpose:
Used to return multiple sets of information from a query.
A CompositeMember annotation is ignored unless is in composite member persistence unit.
A compound expression has a left and right expressions combined by an identifier.
The CONCAT function returns a string that is a concatenation of its arguments.
This
ConcatExpressionFactory creates a new ConcatExpression when the portion of
the query to parse starts with CONCAT.Factory class to create concrete subclasses of abstract classes.
Purpose: Concurrency deadlock or interupts will raise this exception.
INTERNAL:
English ResourceBundle for ConcurrencyException messages.
The query BNF for a conditional expression.
The query BNF for a conditional factor expression.
The query BNF for a conditional primary expression.
The query BNF for a conditional term expression.
The CONNECT BY clause allows selecting rows in a hierarchical order using the hierarchical
query clause.
The query BNF for a
CONNECT BY clause.This
ConnectByClauseFactory creates a new ConnectByClause when the portion of
the query to parse starts with CONNECT BY.
Purpose: Used to specify how a client session's should be allocated.
Default value Transactional causes creation of ClientSession,
the other two values - ExclusiveIsolatedClientSession.
Purpose: Used to specify how connection should be pooled in a server session.
Purpose:
Define an interface for supplying TopLink with a
Connection to
a JDBC database.Purpose: Allows a field to always be mapped to a constant value.
Wrapper over
ConstraintViolation class.In the SELECT clause a constructor may be used in the SELECT list to return one or
more Java instances.
The query BNF for a constructor expression.
This
ConstructorExpressionFactory creates a new ConstructorExpression when the
portion of the query to parse starts with NEW.The query BNF for a constructor item expression.
Purpose: An item specifying a class constructor method to be used in a ReportQuery's returned results.
JPA scripting API implementation.
Purpose:
Concrete class to represent the ConstructorResult structure as defined by
the JPA 2.1 Persistence specification.
Interface used by clients to interact
with the assorted mappings that use
ContainerPolicy.Use this type of MarshalRecord when the marshal target is a
ContentHandler.
Purpose: Conversion exceptions such as method or class not defined will raise this exception.
INTERNAL:
English ResourceBundle for ConversionException messages.
A ConversionValue annotation is used within an ObjectTypeConverter.
JPA scripting API implementation.
The Convert annotation specifies that a named converter should be used with
the corresponding mapped attribute.
JPA scripting API implementation.
A Converter is used to customize the values during the reading from the
database into the object model as well as during the writing back of changes
into the database.
JPA scripting API implementation.
Purpose: Conversion interface to allow conversion between object and data types.
JPA scripting API implementation.
A JPA attribute converter class wrapped with an EclipseLink converter.
A Converters annotation allows the definition of multiple Converter.
Purpose: Define how an object is to be copied.
A helper for copying DataObjects.
A CopyPolicy is used to set an
org.eclipse.persistence.descriptors.copying.CopyPolicy on an Entity.
Purpose: Allows customization of how an object is cloned.
JPA scripting API implementation.
This class exists on on the client side which talks to remote session controller through
RMI connection.
INTERNAL:
org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionController.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from CorbaRemoteSessionControllerSun.idl
Monday, November 19, 2001 1:51:44 o'clock PM EST
RemoteSessionController sits between the remote session and the session.
INTERNAL:
org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionControllerHelper.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from CorbaRemoteSessionControllerSun.idl
Monday, November 19, 2001 1:51:44 o'clock PM EST
INTERNAL:
org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionControllerHolder.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from CorbaRemoteSessionControllerSun.idl
Monday, November 19, 2001 1:51:44 o'clock PM EST
INTERNAL:
org/eclipse/persistence/remote/corba/sun/CORBARemoteSessionControllerOperations.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from CorbaRemoteSessionControllerSun.idl
Monday, November 19, 2001 1:51:44 o'clock PM EST
INTERNAL
A abstraction of attribute accessor capturing behavior common to all
persistence types.
INTERNAL
Purpose: A generic super class for AttributeGroup and other subclasses
INTERNAL
Purpose: Generic superclass for AttributeItem.
INTERNAL
A abstraction of converter capturing behavior common to all persistence
types.
CoreDescriptor<ATTRIBUTE_GROUP extends CoreAttributeGroup,DESCRIPTOR_EVENT_MANAGER extends CoreDescriptorEventManager,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField,INHERITANCE_POLICY extends CoreInheritancePolicy,INSTANTIATION_POLICY extends org.eclipse.persistence.internal.core.descriptors.CoreInstantiationPolicy,LIST extends List,OBJECT_BUILDER extends org.eclipse.persistence.internal.core.descriptors.CoreObjectBuilder>
INTERNAL
A abstraction of descriptor capturing behavior common to all persistence
types.
INTERNAL
A abstraction of descriptor event capturing behavior common to all
persistence types.
INTERNAL
A abstraction of descriptor event manager capturing behavior common to all
persistence types.
This interface is used by the Transformation Mapping to build the value for a
specific field.
CoreInheritancePolicy<ABSTRACT_RECORD extends org.eclipse.persistence.internal.core.sessions.CoreAbstractRecord,ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,DESCRIPTOR extends CoreDescriptor,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField>
INTERNAL
A abstraction of inheritance policy capturing behavior common to all
persistence types.
INTERNAL
A abstraction of login capturing behavior common to all persistence types.
CoreMapping<ATTRIBUTE_ACCESSOR extends CoreAttributeAccessor,ABSTRACT_SESSION extends org.eclipse.persistence.internal.core.sessions.CoreAbstractSession,CONTAINER_POLICY extends org.eclipse.persistence.internal.core.queries.CoreContainerPolicy,DESCRIPTOR extends CoreDescriptor,FIELD extends org.eclipse.persistence.internal.core.helper.CoreField>
INTERNAL
A abstraction of mapping capturing behavior common to all persistence types.
INTERNAL
A abstraction of project capturing behavior common to all persistence types.
CoreSession<DESCRIPTOR extends CoreDescriptor,LOGIN extends CoreLogin,PLATFORM extends org.eclipse.persistence.internal.core.databaseaccess.CorePlatform,PROJECT extends CoreProject,SESSION_EVENT_MANAGER extends CoreSessionEventManager>
INTERNAL
A abstraction of session capturing behavior common to all persistence types.
INTERNAL
A abstraction of session event listener capturing behavior common to all
persistence types.
INTERNAL
A abstraction of sessuin event manager capturing behavior common to all
persistence types.
One of the aggregate functions.
This
CountFunctionFactory creates a new CountFunction when the portion of the
query to parse starts with COUNT.Purpose:
Abstract class for CursoredStream and ScrolableCursor
Purpose:
Stream class which is used to deal with large collections returned
from TOPLink queries more efficiently.
Purpose:
Used to support cursored streams in a read query.
Purpose:
Abstract class for all Cursor-related policy objects
The Customizer annotation is used to specify a class that implements the
org.eclipse.persistence.config.DescriptorCustomizer
interface and is to run against an entity's class descriptor after all
metadata processing has been completed.
PUBLIC:
Defines a user defined partitioning policy.
INTERNAL:
This is the concrete subclass responsible for handling backward compatibility for 9.0.4.
PUBLIC:
A CacheInvalidationPolicy that allows objects to expire every day at a specific time.
Configures what type of database change notification an entity/descriptor should use.
PUBLIC:
Defines the API for integration with a database event notification service.
Provides a mechanism for plugging in database event listener creation.
Purpose:
Wrapper for any database exception that occurred through EclipseLink.
INTERNAL:
English ResourceBundle for DatabaseException messages.
Purpose:
Hold the configuration information necessary to connect to a JDBC driver.
Purpose: Defines how an attribute of an object maps to and from the database
Purpose: Define a database object for the purpose of creation and deletion.
DatabasePlatform is private to EclipseLink.
Purpose: Abstract class for all database query objects.
Used for parameter retreival in JPQL
Purpose: Define a representation of a database row as field=>value pairs.
Purpose: Add login and configuration API to that of Session.
This expression represents the database specific data type, which may include size and scale.
The query BNF for the database type.
A Factory for creating DataObjects.
Deprecated.
.
Data helper methods.
Purpose:
Concrete class used for executing non selecting SQL strings.
A data object is a representation of some structured data.
PUBLIC:
Defines the API for the integration with an external DataSources data partitioning support.
Purpose:
Concrete class to perform read using raw SQL.
JPA scripting API implementation.
Purpose:
Hold the configuration information necessary to connect to a datasource.
This
Expression represents a date or time.The query BNF for a date/time expression.
This
DateTimeFactory creates a new DateTime when the portion of the query to
parse starts with CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP or with the
JDBC escape format used for date/time/timestamp.The query BNF for a date/time primary expression.
The query BNF for a date/time/timestamp expression.
Purpose: Provides DB2 Mainframe specific behavior.
Purpose: Provides DB2 specific behavior.
Purpose: Provides DB2 z/OS specific behavior.
Purpose: Provides DBase specific behavior.
PUBLIC: runtime exception for EclipseLink DBWS Service
INTERNAL:
Purpose:
PUBLIC: model object for eclipselink-dbws.xml descriptor file.
Purpose:Use this Connector to build a java.sql.Connection in the
"standard" fashion, via the DriverManager.
This
JPQL grammar provides support for parsing JPQL queries defined by the
JPA 2.1 functional specification and the EclipseLink 2.6.INTERNAL:
A default implementation of ErrorHandler that simply rethrows the SAXParseExceptions.
This
JPQL grammar provides support for parsing JPQL queries defined in the
latest JPA functional specification.Purpose: Default implementation of the org.eclipse.persistence.sdo.helper.SchemaLocationResolver interface
By default set a Map keyed on QName of types and value is the schemaLocation
Purpose: Default implementation of the org.eclipse.persistence.sdo.helper.SchemaResolver interface
Purpose: Reference to the default sequence.
Purpose: Default log used for the session when message logging is
enabled.
An implementation of an
Expression that wraps a string.DefaultTableGenerator is a utility class used to generate a default table schema for a EclipseLink project object.
Purpose:Provide a default implementation of the UnmappedContentHandler
Purpose:Default implementation of the ValueStore interface.
Class called to transform Java names to XML names.
PUBLIC:
A DeferredChangeDetectionPolicy defers all change detection to the UnitOfWork's
change detection process.
A DeleteAll annotation is specified to indicate that when an relationship
is deleted, it should use a delete all query.
Purpose:
Query used to delete a collection of objects.
This is the delete clause of the delete statement.
The query BNF for the delete clause.
This
DeleteClauseFactory creates a new DeleteClause when the portion of the query
to parse starts with DELETE FROM.The query BNF for a range variable declaration expression used by the DELETE clause, which
accepts collection and aggregate expression, which is used by invalid queries.
Purpose: Used for deleting objects.
Bulk delete operation apply to entities of a single entity class (together with its subclasses,
if any).
The query BNF for the delete statement.
This
DeleteStatementFactory creates a new DeleteStatement when the portion of the
query to parse starts with DELETE FROM.Purpose: Provides Derby DBMS specific behavior.
The query BNF for a derived collection member declaration expression.
Extends EclipseLink's database event listening capabilities by allowing a listener to subscribe to
to change notifications from the database
This listener also expands the interface to support subscription on a descriptor basis rather than
the wholesale subscription provided by its superclass.
Customize a
ClassDescriptor when the
DescriptorCustomizer.customize(ClassDescriptor) method is called during the
loading/population of the mappings.Purpose: Encapsulate the information provided with descriptor events.
Purpose: Provides an empty implementation of DescriptorEventListener.
Purpose: Used to support Java event listener event model on descriptors.
Purpose: The event manager allows for a descriptor to specify that
an object should be notified when a EclipseLink event occurs.
Purpose: This exception is used for any problem that is detected with a descriptor or mapping.
INTERNAL:
English ResourceBundle for DescriptorException messages.
Purpose: The query manager allows for the database operations that EclipseLink
performs to be customized by the application.
Purpose: Provide a dynamic interface into the EclipseLink Identity Map Manager.
Purpose: This interface defines the API for the ChangeRecord that holds the changes made to a direct collection attribute of
an object.
Purpose: This mapping is used to store a collection of simple types (String, Number, Date, etc.)
into a single table.
Purpose:Represents a direct collection join query.
Purpose:Use this Connector to build a java.sql.Connection by
directly instantiating the Driver, as opposed to using the DriverManager.
An enum that is used within the StoredProcedureParameter annotation.
Mapping for a collection of key-value pairs.
Purpose: Define an alias to a database field.
Purpose:
Concrete class to perform a direct read.
Purpose: This interface provides public API to the class responsible for holding the change made to a directToFieldMapping.
Purpose: Maps an attribute to the corresponding database field type.
Purpose: Mapping used to map from a DOM (org.w3c.Document) or XML String into
an Oracle XMLType field, in Oracle 9i XDB.
Instances of this exception are raised if a problem is detected during the
discovery of a TopLink cluster.
INTERNAL:
English ResourceBundle for ConcurrencyException messages.
Purpose: Detects new members of a logical EclipseLink cluster.
A DiscriminatorClass is used within a VariableOneToOne annotation.
JPA scripting API implementation.
JPA scripting API implementation.
Purpose: Super class to all remote client session's.
One of the four binary operators.
Purpose: Define the interface of EclipseLink profiler for using DMS gate.
Purpose:Provides an interface for customizing how Documents are
preserved.
Purpose:
This should only be used by the descriptor, this should not be executed directly.
INTERNAL:
DOMRecord is an extension of the JCA Record interface that
provides support for XML data.PUBLIC:
Provides a Record/Map API on an XML DOM element.
This custom ClassLoader provides support for dynamically generating classes
within an EclipseLink application using byte codes created using a
DynamicClassWriter.Write the byte codes of a dynamic entity class.
DynamicEntity is the public interface for dealing with dynamic persistent objects.Custom exception type that provides information about failure cases
encountered when using a GenericEntity with TopLink.
A DynamicHelper provides some utility methods to simplify application
development with dynamic types.
A SessionCustomizer which configures all descriptors as dynamic entity
types.
Custom CMPPolicy to handle Object[].
A specialized
JAXBContext for marshalling and unmarshalling DynamicEntities.
DynamicJAXBContextFactory allows the user to create a DynamicJAXBContext without having
realized Java classes available on the classpath.
This custom ClassLoader provides support for dynamically generating classes
within an JPA-RS EclipseLink application using byte codes created using a
DynamicClassWriter.Extended SchemaManager to handle the creation of tables for dynamic types.
An EntityType provides a metadata facade into the EclipseLink
object-relational metadata (descriptors & mappings) with specific knowledge
of the entity types being dynamic.
The EntityTypeBuilder is a factory class for creating and extending dynamic
entity types.
MetadataSource used in the creation of dynamic JAXB contexts for applications.MetadataSource used in the creation of dynamic JAXB contexts
for applications in JPARS v2.0.This visitor allows a subclass to simply override
AnonymousExpressionVisitor.visit(Expression) and perform the
same task for all visited expressions including those defined by EclipseLink.
Purpose: Any exception raised by EclipseLink should be a subclass of this exception class.
The
ExpressionVisitor that adds support for the additional JPQL identifiers supported by
EclipseLink that is not defined in the JPA function specification.This validator adds EclipseLink extension over what the JPA functional specification had defined.
This
JPQL grammar provides support for parsing JPQL queries defined in
JSR-220 - Enterprise JavaBeans 3.0.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0 and the additional
support provided by EclipseLink 2.1.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional
support provided by EclipseLink 2.4.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional
support provided by EclipseLink 2.5.This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-338 - Java Persistence 2.1 and the additional
support provided by EclipseLink 2.6.This visitor traverses an
Expression
and retrieves the "literal" value.INTERNAL:
This extension provides additional support to semantic validation by adding support for non-JPA
specific artifacts, such as database objects.
An enumeration listing the various releases of EclipseLink.
EISAccessor is an implementation of the Accessor
interface.INTERNAL:
Capture the changes for an unordered collection as
collections of adds and removes.
Purpose: To provide API into the EISCollectionChangeSet.
EIS Composite Collection Mappings map a java.util.Map or java.util.Collection of Java objects
to an EIS record in a privately owned, one-to-many relationship according to its descriptor's
record type.
EIS Composite Direct Collection Mappings map a collection of simple Java attributes
to and from an EIS Record according to its descriptor's record type.
EIS Composite Object Mappings map a Java object to a privately owned, one-to-one
relationship to an EIS Record according to its descriptor's record type.
An
EISConnectionSpec specifies how the
jakarta.resource.cci.Connection is accessed.An
EISDescriptor defines the mapping from a JCA data
structure to a Java object.EIS Direct Mappings map a simple Java attribute to and from an EIS Record according to
its descriptor's record type.
An
EISDOMRecord is a wrapper for a DOM tree. Use an
EISException when any problem is detected while
interacting with an EIS datasourceINTERNAL:
English ResourceBundle for EISException messages.
Defines the specification for a call to a JCA interaction.
An
EISLogin defines connection information and datasource
properties.An
EISMappedRecord acts as a Record
wrapper.INTERNAL
All mappings which can be added to org.eclipse.persistence.eis.EISDescriptor must
implement this interface.
INTERNAL:
An EIS one-to-many mapping is a reference mapping that represents the relationship between
a single source object and a collection of mapped persistent Java objects.
INTERNAL:
Helper class to consolidate all the heinous comparing
and merging code for the EIS one to many mappings.
An EIS one-to-one mapping is a reference mapping that represents the relationship between
a single source object and a single mapped persistent Java object.
INTERNAL:
Capture the changes for an ordered collection where
the entire collection is simply replaced if it has changed.
Purpose: To provide API into the EISCollectionChangeSet.
An
EISPlatform defines any EIS adapter specific behavior.The
EISSequence class allows access to sequence resources
using custom read (ValueReadQuery) and update (DataModifyQuery) queries and a
user specified preallocation size.EIS Transformation Mappings allow the creation of custom mappings where one or more fields
in an EIS Record can be used to create the object to be stored in a Java class's attribute.
JPA scripting API implementation.
An ElementDeclaration object is used to represent the information that is
associated with a global element in XML.
The query BNF for a else expression specified in the case expression.
JPA scripting API implementation.
INTERNAL
Common interface to those mappings that are used to map JPA Embedded objects.
JPA scripting API implementation.
JPA scripting API implementation.
This expression tests whether or not the collection designated by the collection-valued path
expression is empty (i.e, has no elements).
The query BNF for an empty collection comparison expression.
This
Expression represents an identification variable that maps a Map
property, either the key, the value or a Map.Entry).JPA scripting API implementation.
The query BNF for a entity expression.
JPA scripting API implementation.
The class defines EclipseLink properties' names for use at the EntityManager level.
INTERNAL:
English ResourceBundle for EntityManagerSetupException messages.
The query BNF for a entity or value expression.
Entity resource.
Deprecated.
Use
EntityResource instead.JPA scripting API implementation.
Purpose:
Concrete class to represent the EntityResult structure as defined by
the EJB 3.0 Persistence specification.
The query BNF for the TYPE expression.
This
Expression wraps the name of an entity type.The query BNF for the entity type literal.
This factory creates an
EntityTypeLiteral, which wraps an entity name.An identification variable qualified by the
ENTRY operator is a path
expression.This
EntryExpressionFactory creates a new EntryExpression when the portion of the
query to parse starts with ENTRY.JPA scripting API implementation.
The query BNF for a enum expression.
The query BNF for an enumeration constant expression.
The query BNF for an enum primary expression.
Purpose: Object type converter is used to match a fixed number of
database data values to a Java enum object value.
INTERNAL:
A helper for comparing DataObjects.
Makes the ErrorResponse class available to JAXB context.
Exception handler can catch errors that occur on queries or during database access.
INTERNAL:
Utility class to generate exception messages using ResourceBundles.
INTERNAL:
English ResourceBundle for EclipseLinkException messages.
Specifies default mappings (those that are not explicitly decorated in XML or
using annotations)should be omitted.
This property could be specified while creating either EntityManagerFactory
(createEntityManagerFactory or persistence.xml)
or EntityManager (createEntityManager); the latter overrides the former.
The ExistenceChecking annotation is used to specify the type of checking
EclipseLink should use when determining if an entity is new or existing.
An enum that is used within the ExistenceChecking annotation.
An EXISTS expression is a predicate that is
true only if the result of the
subquery consists of one or more values and that is false otherwise.The query BNF for the exists expression.
This
ExistsExpressionFactory creates a new ExistsExpression when the portion of
the query to parse starts with EXISTS.
Purpose: Define an object-level representation of a database query where clause.
This is the root interface of the parsed tree representation of a JPQL query.
Purpose: Allow for instances of expression to be created.
An
ExpressionFactory is responsible to parse a portion of JPQL query which starts
with one of the factory's JPQL identifiers.
Purpose: This class mirrors the java.lang.Math class to allow mathimetical function support within expressions.
Purpose: ADVANCED: The expression operator is used internally to define SQL operations and functions.
This registry contains the necessary information used by Hermes parser.
A utility class containing various methods related to the Hermes parser.
This interface is used to traverse the JPQL parsed tree.
This
ExpressionVisitor wraps another ExpressionVisitor and delegates all its
calls to it (the delegate).
Purpose: This subclass is intended to be used with external connection pools.
Delegates DataObject serialization while ensuring implementation independent
java.io.Serialization.
Purpose: Interface for external transaction management.
The EXTRACT function extracts a date part from a date/time value.
The query BNF for the
EXTRACT function.This
ExtractExpressionFactory creates a new ExtractExpression when the portion of
the query to parse starts with EXTRACT.Visitor for
Facet.Common interface for all response builders.
Response builder used in JPARS 1.0 and earlier versions.
This interface represents a set of JPARS features.
The legacy initial feature set.
Feature set for service version 2.0.
A fetch attribute is specified within a fetch group and is used as a
performance enhancement that allows a group of attributes of an object to be
loaded on demand, which means that the data for an attribute might not loaded
from the underlying data source until an explicit access call for the
attribute first occurs.
JPA scripting API implementation.
A fetch group is a performance enhancement that allows a group of attributes
of an object to be loaded on demand, which means that the data for an
attribute might not loaded from the underlying data source until an explicit
access call for the attribute first occurs.
JPA scripting API implementation.
A FetchGroup is a performance enhancement that allows a group of attributes
of an object to be loaded on demand, which means that the data for an
attribute might not loaded from the underlying data source until an explicit
access call for the attribute first occurs.
Purpose: The fetch group manager controls the named fetch groups defined at
the descriptor level.
Purpose:
Provide a very simple low overhead means for measuring fetch group field usage.
A FetchGroups annotation allows the definition of multiple FetchGroup.
Purpose: The fetch group tracker interface provides a set of APIs which
the domain object must implement, in order to take advantage of the EclipseLink fetch group
performance enhancement feature.
JPA scripting API implementation.
Purpose: Define a database field definition for creation within a table.
PUBLIC:
FieldPartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's id, location, or tenant.
JPA scripting API implementation.
Purpose:
Concrete class to represent the FieldResult structure as defined by
the EJB 3.0 Persistence specification.
Filter for fields filtering (projection) feature.
Fields filtering feature validator/processor.
Type of fields filter.
Purpose: An abstract superclass of some implementations of the OptimisticLockingPolicy
interface.
PUBLIC:
This interface is used by the Transformation Mapping to build the value for a
specific field.
Purpose: Provides an empty implementation of FieldTransformer.
Purpose: Support serializing/deserializing a project representing application metadata
to/from a file.
Purpose:Used in conjunction with SDOClassGenerator.
INTERNAL:
Purpose: Provide common file I/O utilities
A filter is used to determine if a value can be "accepted" or "rejected".
FlushClearCache persistence property
defines modes of cache handling after em.flush call followed by em.clear call.
JPA scripting API implementation.
Purpose: Define a foreign key from one table to another.
Purpose: Abstract class for relationship mappings
Purpose: Define an alias to a foreign object.
Use this type of MarshalRecord when the marshal target is an OutputStream and the
XML should be formatted with carriage returns and indenting.
Use this type of MarshalRecord when the marshal target is a Writer and the
XML should be formatted with carriage returns and indenting.
The FROM clause of a query defines the domain of the query by declaring identification
variables.
The query BNF for the from clause.
This
FromClauseFactory creates a new FromClause when the portion of the query to
parse starts with FROM.This visitor makes sure that all path expressions are fully qualified with a "virtual"
identification variable if the range variable declaration does not define one.
This expression adds support to call native database functions.
The query BNF for the EclipseLink's function expression.
This
FunctionExpressionFactory creates a new FunctionExpression when the portion
of the query to parse starts with an identifier related to a SQL function.The number of parameters a
FunctionExpression can have.The query BNF for the parameters of a function expression.
The query BNF for a function expression returning a date/time value.
The query BNF for a function expression returning a numeric value.
The query BNF for a function expression returning a string value.
The query BNF for a general case expression.
This
ValueExpressionFactory creates a general identification variable, which is either
with the identifier KEY or VALUE and then checks the existence of a path expression.The query BNF for a general identification variable expression.
JPA scripting API implementation.
INTERNAL:
A generic
JPQLQueryBNF can be used to manually create a new BNF without having to create
a concrete instance.PUBLIC:
This is the concrete subclass responsible for representing Glassfish server behavior.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for Glassfish JTA
Purpose: TransactionController implementation for Glassfish JTA
PUBLIC:
Integrates with WebLogic GirdLink's data affinity support.
The GROUP BY construct enables the aggregation of values according to the properties of an
entity class.
The query BNF for the group by clause.
This
GroupByClauseFactory creates a new GroupByClause when the portion of the
query to parse starts with GROUP BY.The query BNF for a group by item expression.
This
GroupByItemFactory is responsible to return the right expression and to support
invalid expression as well.Database Platform for SAP HANA
HashPartitioning partitions access to a database cluster by the hash of a field value from the object,
such as the object's location, or tenant.
JPA scripting API implementation.
PUBLIC:
HashPartitioningPolicy partitions access to a database cluster by the hash of a field value from the object,
such as the object's location, or tenant.
The HAVING construct enables conditions to be specified that further restrict the query
result as restrictions upon the groups.
The query BNF for the having clause.
This
HavingClauseFactory creates a new HavingClause when the portion of the query
to parse starts with HAVING.INTERNAL:
This interface represents a helper execution context.
This class instantiates a HelperProviderImpl that returns concrete helpers.
If a table contains hierarchical data, then rows can be selected in a hierarchical order using
the hierarchical query clause.
This
HierarchicalQueryClauseFactory creates a new HierarchicalQueryClause
when the portion of the query to parse starts with either VERSIONS or
AS OF.Hint values.
Purpose:Expresses how historical data is saved on the data store.
A collection of static methods used to build 'href' attribute values for REST 'link' elements.
Purpose: Provides HSQL specific behavior.
JPA scripting API implementation.
An identification variable is a valid identifier declared in the FROM clause of a query.
The query BNF for an identification variable expression.
An identification variable is a valid identifier declared in the FROM clause of a query.
The query BNF for an identification variable declaration expression.
This
IdentificationVariableDeclarationFactory handles parsing the JPQL fragment
within the FROM clause.This
IdentificationVariableFactory creates a new IdentificationVariable.A role describes the purpose of the JPQL identifier.
PUBLIC:
IdentityMapAccessor provides the public interface into all functionality associated with
EclipseLink's cache.
EclipseLink helper class used for converting composite key values passed into
JAX-RS calls as query or matrix parameters into a value that can be used in a
find.
IDResolver can be subclassed to allow customization of the ID/IDREF processing of
JAXBUnmarshaller.
IDResolver can be subclassed to allow customization of the ID/IDREF processing of
XMLUnmarshaller.
IdValidation configures which id values are considered valid when loading
from the database.
INTERNAL:
Allow a database INDEX to be define when generating DDL.
JPA scripting API implementation.
Purpose: Allow for indexes to be created.
Defines the specification for a call to a JCA interaction that uses indexed records.
Allow a set of database indexes to be define on an Entity.
The INDEX function returns an integer value corresponding to the position of its argument
in an ordered list.
This
IndexExpressionFactory creates a new IndexExpression when the portion of the
query to parse starts with INDEX.Purpose:
Common interface to indirect collections.
Provides factory methods to create JDK specific implementation
of particular type of
IndirectCollection.Define API providers of
IndirectCollection implementations must conform to.Purpose:
Define an interface for a Container that can also act as an EclipseLink
"indirection" object; i.e.
IndirectList allows a domain class to take advantage of TopLink indirection
without having to declare its instance variable as a ValueHolderInterface.
IndirectMap allows a domain class to take advantage of TopLink indirection
without having to declare its instance variable as a ValueHolderInterface.
IndirectSet is an example implementation of the Set protocol that
allows a domain class to take advantage of TopLink Indirection
without having to declare its instance variable as a ValueHolderInterface.
The state field path expression must have a string, numeric, or enum value.
The query BNF for an in expression.
The query BNF describes the expression being tested by the
IN expression.This
InExpressionFactory creates a new InExpression when the portion of the query
to parse starts with IN or NOT IN.The query BNF for the items of an IN expression.
An
InformixPlatform that fixes many EclipseLink bugs
related to Informix support.Purpose: Provides Informix specific behavior.
JPA scripting API implementation.
Purpose: Allows customization of an object's inheritance.
This archive is designed for use with dynamic persistence units
it is built with a stream that allows it to read a persistence.xml file and creates a fake base URL
based the classpath location of the InMemoryArchive class
Purpose:
Provide a means of controlling the behavior of in-memory and conforming queries
that access un-instantiated indirection objects in processing the query against cached objects.
Either positional or named parameters may be used.
The query BNF for a input parameter.
Purpose:
Used for inserting new objects into the database.
Purpose: A converter used in conjunction with sdoJava:instanceClass
The customClass on the converter must be set and that class must have
a Constructor that takes a String argument and a toString method.
An InstantiationCopyPolicy is used to set an
org.eclipse.persistence.descriptors.copying.InstantiationCopyPolicy on an
Entity.
Purpose: This is the default copy policy.
JPA scripting API implementation.
Purpose: IntegrityChecker is used for catching all the descriptor exceptions,
and checking database tables.
Purpose: IntegrityExceptions is used to throw all the Descriptors exceptions.
Purpose: Allows for a descriptor's implemented interfaces to be configured.
The query BNF for the parameter of an aggregate expression.
The query BNF for the lower and upper expressions defined in the between expression.
The query BNF for the parameters defined in the coalesce expression.
The query BNF for the items of a COLUMN expression.
The query BNF for the COUNT expression's encapsulated expressions.
The query BNF for the parameter of the COUNT function.
The query BNF for the parameters defined in the type expression.
The query BNF for the
FROM declaration, basically what follows the
FROM identifier.The query BNF for what's following the join identifier.
The query BNF for the parameter of the
LENGTH expression.The query BNF for the first two parameters of the
LOCATE expression.The query BNF for the third parameter of the
LOCATE expression.The query BNF for the parameter of the
LOWER expression.The query BNF for the parameters of the
MOD expression.The query BNF for what's following the order by identifier.
The query BNF for an order by item.
This
InternalOrderByItemFactory creates either a StateFieldPathExpression or
an IdentificationVariable.The query BNF for the from declaration used in a subquery.
The query BNF for the parameter of the
SQRT expression.The query BNF for the position parameters of the
SUBSTRING expression.The query BNF for the parameter of the
LENGTH expression.The query BNF for what's following the update identifier.
The query BNF for the parameter of the
UPPER expression.The query BNF for the expression following the WHEN identifier.
This
IsExpressionFactory creates a new expression when the portion of the query to parse
starts with IS.PUBLIC:
Description:
This null policy allows for various configurations of isSet behavior to be set.
Marshal:
The boolean value of the isSet() state of a node will determine whether a node will be written out for a null value.
Marshal:
The boolean value of the isSet() state of a node will determine whether a node will be written out for a null value.
Convenient
ItemLinks object builder.Makes the ItemLinks class available in our Dynamic JAXB context.
INTERNAL:
INTERNAL:
Java class for java-attribute complex type.
INTERNAL:
INTERNAL:
INTERNAL:
Purpose: JavaModel representation of a java.lang.reflect.Constructor object.
Purpose: JavaModel representation of a java.lang.reflect.Constructor object.
Purpose: Allows to use JavaDBPlatform as a synonym for DerbyPlatform
INTERNAL:
INTERNAL:
INTERNAL:
Makes java.lang package classes available to JPA-RS JAXB context.
PUBLIC:
Makes java.math package classes available to JPA-RS JAXB context.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
Plain old Java serialization.
Java class for anonymous complex type.
Java class for anonymous complex type.
Makes java.util package classes available to JPA-RS JAXB context.
INTERNAL
A wrapper for the SDOClassGenerator that understands the JAXB compiler options
and translates them to the SDO equivalents.
Purpose:Provide a EclipseLink implementation of the JAXBContext interface.
The JAXBContextInput is used to create a JAXBContextState which is responsible for accessing
the underlying XMLContext
Purpose:An EclipseLink specific JAXBContextFactory.
These are properties that may be passed in to create a JAXBContext:
This implementation of commonj.sdo.helper.DataFactory is responsible for
ensuring that newly created DataObjects are assigned a JAXB aware value store.
INTERNAL:
Implementation of org.xml.sax.ErrorHandler.
Purpose:
This class provides an implementation of EclipseLinkException specific to the EclipseLink JAXB implementation
INTERNAL:
Purpose:
This class provides a mechanism to obtain the EclipseLink implementation of various JAXB runtime
classes based on a given JAXB class/interface.
The JAXBHelperContext is a bridge between POJOs and SDO DataObjects.
INTERNAL
JAXBList wraps the POJOs collection in order to provide additional SDO information.
INTERNAL:
INTERNAL:
Class used to log warnings during the processing of JAXB annotations and
OXM XML bindings files.
Subclass of JAXBElement to allow the use of ParameterizedTypes.
Purpose: JAXBTypesafeEnumConverter is used to allow mapping to type safe
enums according to the JAXB 1.0 spec.
INTERNAL:
Implementation of UnmarshallerHandler to be used by JAXBUnmarshaller.
INTERNAL:
Facilitates JAXBValidation.
The JAXBValueStore enables a DataObject to access data from a POJO.
This implementation of commonj.sdo.helper.XMLHelper is responsible for
ensuring that newly unmarshalled DataObjects are assigned a JAXB aware
value store.
Purpose: Wrap a org.eclipse.persistence.platform.xml.XMLNamespaceResolver
and expose it as a javax.xml.namespace.NamespaceContext.
Purpose: An implementation of XMLParser using JAXP 1.3 APIs.
Purpose: An implementation of XMLPlatform using JAXP 1.3 APIs.
Purpose: An implementation of XMLTransformer using JAXP 1.3 APIs.
PUBLIC:
This is the concrete subclass responsible for representing JBoss-specific server behavior.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for JBoss JTA
Purpose: TransactionController implementation for JBoss JTA
PUBLIC: Marker interface for JDBC type metadata
PUBLIC: JDBC types
PUBLIC:
A StructConverter that can be used to convert the oracle.spatial.geometry.JGeometry as
it is read and written from the database.
INTERNAL:
English ResourceBundle for JMSProcessingException messages.
This helper class allows access to abstract JMSPublishingTransportManager internals when processing
JMS messages for RCM, and can be expanded upon to include other EclipseLink JMS functionality.
Purpose: Provide a transport implementation for the Remote Command Module (RCM) that publishes
to a JMS topic.
Purpose: Provide a transport implementation for the Remote Command Module (RCM) that both publishes
and subscribes to a JMS topic.
PUBLIC:
This interface must be implemented by server platform classes that have
JMX/MBean functionality enabled in EclipseLink.
As of EclipseLink
As of EclipseLink
PUBLIC:
Subclass of org.eclipse.persistence.platform.server.ServerPlatformBase
in support of the JMXEnabledPlatform interface
Specifies the J2EE DataSource lookup options.
A JOIN enables the fetching of an association as a side effect of the execution of a query.
The query BNF for a join association path expression.
The query BNF for the join expression.
JPA scripting API implementation.
This
JoinFactory creates a new Join when the portion of the query to parse starts
with JOIN or FETCH JOIN, respectively.A JoinFetch annotation can be used on any relationship mapping,
(OneToOne, ManyToOne, OneToMany, ManyToMany, BasicCollection, BasicMap).
The query BNF for the fetch join expression.
An enum type that is used within the JoinFetch annotation.
JPA scripting API implementation.
JPA scripting API implementation.
Purpose: TransactionController implementation for JOTM
Extends JPA Cache interface with additional EclipseLink API.
PUBLIC:
EclipseLInk specific JPA Criteria interface.
Purpose: Defines the Interface for EclipseLink extensions to the EntityManager
Purpose: Defines the Interface for EclipseLink extensions to the EntityManagerFactory
This sample illustrates the JPA helper methods that may be of use
to EclipseLink customers attempting to leverage EclipseLink specific functionality.
PUBLIC:
EclipseLInk specific JPA query interface.
This interface defines the entry point for implementing a JPQL query parsing
system in EclipseLink.
Logger for EclipseLink JPA-RS related functionality.
An enumeration listing the various releases of the Java Persistence specification.
Purpose: Used as an abstraction of a database invocation.
Purpose: EJBQL parsing and resolution problems will raise this exception
INTERNAL:
English ResourceBundle for EJBQLException.
A
JPQLExpression is the root of the parsed tree representation of a JPQL query.A JPQL grammar defines how a JPQL query can be parsed.
This
JPQLGrammar provides support for parsing JPQL queries defined in JSR-220 - Enterprise JavaBeans 3.0.This
JPQLGrammar provides support for parsing JPQL queries defined in
JSR-337 - Java Persistence 2.0.This
JPQLGrammar provides support for parsing JPQL queries defined in
JSR-338 - Java Persistence 2.1.This defines a single Backus-Naur Form (BNF) of the JPQL grammar.
A
JPQLQueryDeclaration represents either an identification variable declaration or a
collection member declaration.This enum type defines the various types of declarations supported by both the JPA functional
specification and EclipseLink.
A problem describes an issue found in a JPQL query because it is either grammatically or
semantically incorrect.
The list of messages used by
JPQLQueryProblems when validating a JPQL query.The resource bundle containing the problems encountered in a JPQL query.
The query BNF for the JPQL expression.
Instances of this class are used to maintain state about the current
level of the JSON message being marshalled.
Purpose:
This class provides an implementation of EclipseLinkException specific to the EclipseLink JSON handling (marshall, unmarshall, Jersey provider)
INTERNAL:
Purpose:
Use this type of MarshalRecord when the marshal target is a Writer and the
JSON should be formatted with carriage returns and indenting.
Object to be used with Unmarshaller to unmarshal
JsonParser objects
Usage:
JsonParserSource source = new JsonParserSource(jsonParser);
Object unmarshalled = jaxbUnmarshaller.unmarshal(source);Instances of this class are used to maintain state about the current
level of the JSON message being marshalled.
PUBLIC:
Uses EclipseLink Moxy to convert an object to JSON.
Object to be used with Unmarshaller to unmarshal jakarta.json.JsonStructure objects
(ie: jakarta.json.JsonObject or jakarta.json.JsonArray)
Usage:
JsonStructureSource source = new JsonStructureSource(jsonObject);
Object unmarshalled = jaxbUnmarshaller.unmarshal(source);
JSONWithPadding is used to hold an Object along with the corresponding callback name
to marshal.
Use this type of MarshalRecord when the marshal target is a Writer and the
JSON should not be formatted with carriage returns or indenting.
Instances of this class are used to maintain state about the current
level of the JSON message being marshalled.
Purpose: TransactionController extensions for JTA 1.1
Purpose: Synchronization object implementation for JTA 1.0
Purpose: TransactionController implementation for JTA 1.0
An identification variable qualified by the
KEY operator is a path
expression.This
KeyExpressionFactory creates a new KeyExpression when the portion of the
query to parse starts with KEY.The expression representing some keywords:
TRUE, FALSE or NULL.This
KeywordExpressionFactory creates a new KeywordExpression when the
portion of the JPQL query to parse is FALSE, TRUE or
NULL.The LENGTH function returns the length of the string in characters as an integer.
This
LengthExpressionFactory creates a new LengthExpression when the portion of
the query to parse starts with LENGTH.The LIKE condition is used to specify a search for a pattern.
The query BNF for a expression.
This BNF is used when parsing an invalid fragment or to extend the default grammar.
This
LikeExpressionFactory creates a new LikeExpression when the portion of the
query to parse starts with LIKE or NOT LIKE.Used with JAXB to convert from a URL representing an relationship to an object
It provides functionality at marshall and unmarshall time
At marshall time, the target of a relationship will be marshalled as a URL that could be
used to find the object through a REST service
At unmarsall time, the URL will be deconstructed and used to find the object in JPA.
This class is used to wrap collection of Link objects
Makes the Link class available in our Dynamic JAXB context.
Makes the LinkV2 class available in our Dynamic JAXB context.
INTERNAL:
A ListExpressionOperator is used with an ArgumentListFunctionExpression.
A
ListIterable simply forces the returned object to be an instance of ListIterator.INTERNAL:
The query BNF for literals, which is based on the listing defined in section 4.6.1 of the Java
Specification document for JPA 2.0.
This
LiteralExpressionFactory is responsible to return the right literal expression.Some
Expression can have a "literal",
this enumeration is used to visit an Expression and to retrieve the right value.This visitor traverses an
Expression
and retrieves the "literal" value.Purpose: Used to load specified relationship attributes and nested
relationship attributes.
JPA scripting API implementation.
The LOCATE function returns the position of a given string within a string, starting the
search at a specified position.
This
LocateExpressionFactory creates a new LocateExpression when the portion of
the query to parse starts with LOCATE.EclipseLink categories used for logging name space.
Print a brief summary of a TopLink LogRecord in a human readable
format.
Logger type persistence property values.
This expression represents a logical expression, which means the first and second expressions are
aggregated with either AND or OR.
Purpose: Define the information required to connect to an EclipseLink session.
Log levels for EclipseLink logging.
The LOWER function converts a string to lower case and it returns a string.
This
LowerExpressionFactory creates a new LowerExpression when the portion of the
query to parse starts with LOWER.JPA scripting API implementation.
Purpose: Many to many mappings are used to represent the relationships
between a collection of source objects and a collection of target objects.
Purpose:Represents a m-m join query.
JPA scripting API implementation.
Purpose: Define the relationship to be a ManyToOne.
Purpose: Define a change event for Map types.
A MapComponentMapping is any mapping that can be used as the key or the value
in a mapping that uses a MappedKeyMapContainerPolicy.
JPA scripting API implementation.
The MapKeyConvert annotation specifies that a named converter should be used
with the corresponding mapped attribute key column.
Class for wrapping cache key lookup results.
MapKeyMapping is implemented by DatabaseMappings that can be used to map the key in a map
that uses a MappedKeyMapContainerPolicy.
Defines the specification for a call to a JCA interaction using Mapped records.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
INTERNAL:
These are properties that may be set on an instance of Marshaller.
MarshalRecord<MARSHALLER extends org.eclipse.persistence.internal.oxm.Marshaller>
A MarshalRecord encapsulates the marshal target.
Database Platform for SAP MaxDB.
One of the aggregate functions.
This
MaxFunctionFactory creates a new MaxFunction when the portion of the query
to parse starts with MAX.
Purpose: Provide a dynamic interface into the EclipseLink Identity Map Manager.
Purpose: Provide a dynamic interface into the EclipseLink Identity Map Manager.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
This enum represents the different media types supported by EclipseLink MOXy.
Purpose: Provide a remote command implementation for remote cache
merges of changes.
JPARS 2.0 metadata catalog.
Purpose: Interface used to support additional persistence unit
metadata being provided from outside of what was packaged within the
application.
You may subclass this class rather than implement the MetadataSource
interface allowing insulation from future additions to the interface.
Purpose: To provide a trivial implementation of MetadataSource.
Purpose:
Allows a class to be a
QueryRedirector without implementing
QueryRedirector.Purpose:
Used to allow complex inheritance support.
Purpose:
One of the aggregate functions.
This
MinFunctionFactory creates a new MinFunction when the portion of the query
to parse starts with MIN.The modulo operation finds the remainder of division of one number by another.
This
ModExpressionFactory creates a new ModExpression when the portion of the
query to parse starts with MOD.PUBLIC:
Query used to perform a bulk delete using the expression framework.
Purpose:
Abstract class for all modify queries.
This is an implementation of MessageBodyReader/MessageBodyWriter
that can be used to enable EclipseLink JAXB (MOXy) as the JSON
provider.
Custom XJC implementation that ensures the EclipseLink MOXy-specific
jaxb.properties file is generated in the package where the classes are
created.
One of the four binary operators.
Multitenant specifies that a given entity is shared amongst multiple tenants
of a given application.
JPA scripting API implementation.
A multitenant interface.
Purpose: Maps a multitenant property to the corresponding database
field type.
An enum that is used within the Multitenant annotation.
A Mutable annotation can be used on a @Basic mapping.
Purpose: Provides MySQL specific behavior.
JPA scripting API implementation.
A NamedPLSQLStoredFunctionQueries annotation allows the definition of multiple
NamedPLSQLStoredFunctionQuery.
JPA scripting API implementation.
A NamedPLSQLStoredFunctionQuery annotation allows the definition of queries that
call PLSQL stored functions as named queries.
A NamedPLSQLStoredProcedureQueries annotation allows the definition of multiple
NamedPLSQLStoredProcedureQuery.
JPA scripting API implementation.
A PLSQLNamedStoredProcedureQuery annotation allows the definition of queries that
call PLSQL stored procedures as named queries.
JPA scripting API implementation.
A NamedStoredFunctionQueries annotation allows the definition of multiple
NamedStoredFunctionQuery.
A NamedStoredFunctionQuery annotation allows the definition of queries that
call stored functions as named queries.
JPA scripting API implementation.
A NamedStoredProcedureQueries annotation allows the definition of multiple
NamedStoredProcedureQuery.
A NamedStoredProcedureQuery annotation allows the definition of queries that
call stored procedures as named queries.
JPA scripting API implementation.
INTERNAL:
Purpose:Provides a means to customise the namespace prefixes used while marshalling
An implementation of this class can be set on an instance of XMLMarshaller to allow for
each instance of XMLMarshaller to use different namespace prefixes.
It is common for an XML document to include one or more namespaces.
Purpose: Define a database's native sequencing mechanism.
This class can be used to define the dataType with an ObjectTypeConverter
to have EclipseLink bind the object string value as an NCHAR Oracle type.
This class can be used to define the dataType with an ObjectTypeConverter
to have EclipseLink bind the object string value as an NCLOB Oracle type.
Purpose: Allow for creation of nested table types.
Purpose:
Nested tables are similar to
VARRAYs except internally they store their information in a separate table
from their parent structure's table.The query BNF for a new value expression.
Purpose:Provide a policy that specifies how new XML Elements are added to an
existing XML Document.
Use this type of MarshalRecord when the marshal target is a Node.
PUBLIC:
A cache invalidation policy in which no objects will expire.
The NonCacheable annotation is used to configure caching behavior for
relationships.
PUBLIC:
This platform is used when EclipseLink is not within any server (Oc4j, WebLogic, ...)
This is also the default platform for all newly created DatabaseSessions.
JPA scripting API implementation.
BNF:
expression ::= NOT conditional_primaryThis
NotExpressionFactory creates a new NotExpression when the portion of the
query to parse starts with NOT.This class can be used to define the dataType with an ObjectTypeConverter
to have EclipseLink bind the object string value as an NCLOB Oracle type.
A null comparison tests whether or not the single-valued path expression or input parameter is a
NULL value.
The query BNF for a null comparison expression.
A
null Expression is used instead of a true null, which allows
operations to be performed without doing a null check first.A
null implementation of a Filter.NULLIF returns the first expression if the two expressions are not equal.
The query BNF for a nullif expression.
This
NullIfExpressionFactory creates a new NullIfExpression when the portion of
the query to parse starts with NULLIF.PUBLIC:
Description:
This null policy is the default implementation class.
Marshal:
The boolean value of the isSet() state of a node has no effect on whether a node will be written out for a null value - a set is always performed unless the isSetPerformedForAbsentNode flag is set to false for absent nodes.
Unmarshal:
Marshal:
The boolean value of the isSet() state of a node has no effect on whether a node will be written out for a null value - a set is always performed unless the isSetPerformedForAbsentNode flag is set to false for absent nodes.
Unmarshal:
Exact numeric literals support the use of Java integer literal syntax as well as SQL exact
numeric literal syntax.
The query BNF for a numeric literal.
Purpose:
In an object-relational data model, structures can contain "Arrays" or collections of other data-types.
Purpose:
Abstract class for all read queries that build objects and potentially manipulate
the TopLink cache.
INTERNAL:
Implementers of ObjectChangePolicy implement the code which computes changes sets
for the UnitOfWork commit process.
Purpose: Provides API to the Class that holds all changes made to a particular Object.
PUBLIC:
A ObjectChangeTrackingPolicy allows an object to calculate for itself whether
it should has changed by implementing ChangeTracker.
Stand-alone identification variables in the SELECT clause may optionally be qualified by
the OBJECT operator.
The query BNF for an object expression.
This
ObjectExpressionFactory creates a new ObjectExpression when the portion of
the query to parse starts with OBJECT.This object contains factory methods for each
Java content interface and Java element interface
generated in the org.eclipse.persistence.jaxb.xmlmodel package.
This type represents the root of an object graph that will be used
as a template to define the attribute nodes and boundaries of a
graph of JAXB objects and relationships.
Builds object graph for JPARS 2.0.
Purpose:
Abstract class for all object modify queries.
Purpose:
Abstract class for all read queries using objects.
Purpose: Provides API for the ObjectReferenceChangeRecord.
Purpose: Abstract class for 1:1, variable 1:1 and reference mappings
INTERNAL:
A database field of object-relational type: either a java.sql.Array,
java.sql.Struct, or java.sql.Ref.
Purpose:
Differentiates object-relational descriptors from normal relational descriptors.
The ObjectTypeConverter annotation is used to specify a TopLink
org.eclipse.persistence.mappings.converters.ObjectTypeConverter that converts a fixed
number of database data value(s) to Java object value(s) during the reading
and writing of a mapped attribute
An ObjectTypeConverter must be be uniquely identified by name and can be
defined at the class, field and property level and can be specified within
an Entity, MappedSuperclass and Embeddable class.
JPA scripting API implementation.
Purpose: Object type converter is used to match a fixed number of database data values
to Java object value.
An ObjectTypeConverters annotation allows the definition of multiple
ObjectTypeConverter.
Purpose: Allow for creation of object varray type.
PUBLIC:
This is the concrete subclass responsible for representing Oc4j-specific server behavior.
Purpose: TransactionController implementation for OC4J JTA
Returns an expression that allows a join ON clause to be defined.
The query BNF for the on clause.
This
OnClauseFactory creates a new OnClause when the portion of the query to
parse starts with ON.JPA scripting API implementation.
Purpose: This mapping is used to represent the
typical RDBMS relationship between a single
source object and collection of target objects; where,
on the database, the target objects have references
(foreign keys) to the source object.
Purpose:Represents a 1-m join query.
JPA scripting API implementation.
Purpose: One to one mappings are used to represent a pointer references
between two java objects.
Mode for writeFromObjectIntoRowInternal method
Purpose: Define an alias to a foreign one to one object.
Utility class used for processing an XPath Expression into postfix
notation.
Purpose: This exception is used when TopLink's optimistic locking feature is used.
INTERNAL:
English ResourceBundle for OptimisticLockException messages.
The OptimisticLocking annotation is used to specify the type of optimistic
locking TopLink should use when updating or deleting entities.
JPA scripting API implementation.
An enum that is used within the OptimisticLocking annotation.
Purpose:
Supports usage of certain Oracle JDBC specific APIs.
Purpose:
Provides Oracle version specific behavior when
org.eclipse.persistence.oracle bundle is not available.
Purpose:
Supports usage of certain Oracle JDBC specific APIs for the Oracle 11 database.
Purpose:
Provides Oracle version specific behavior when
org.eclipse.persistence.oracle bundle is not available.
Purpose:
Supports usage of certain Oracle JDBC specific APIs for the Oracle 12 database.
Identity column:
Identity column:
GENERATED [ ALWAYS | BY DEFAULT [ ON NULL ] ] AS IDENTITY [ ( identity_options ) ]Purpose:
Provides Oracle version specific behavior when
org.eclipse.persistence.oracle bundle is not available.
Purpose:
Supports certain new Oracle 8 data types, and usage of certain Oracle JDBC specific APIs.
Purpose:
Provides Oracle version specific behavior when
org.eclipse.persistence.oracle bundle is not available.
Purpose:
Supports usage of certain Oracle JDBC specific APIs.
Purpose:
Provides Oracle version specific behavior when
org.eclipse.persistence.oracle bundle is not available.
INTERNAL:
This class used for binding of NCHAR, NSTRING, NCLOB types.
JPA scripting API implementation.
An OracleArray annotation is used to define an Oracle database VARRAY type.
An OracleArrays annotation allows the definition of multiple VARRAY types.
PUBLIC:
Listener for Oracle Database Change event Notification (DCN).
Helper class to abstract the XML mapping for DirectToXMLType.
PUBLIC:
This class allows connection to open proxy session.
JPA scripting API implementation.
An OracleObject annotation is used to define an Oracle database OBJECT type.
An OracleObjects annotation allows the definition of multiple Oracle OBJECT
types.
Purpose: Provides Oracle specific behavior.
PUBLIC: Marker interface for Oracle PL/SQL types
PUBLIC: Oracle PL/SQL types
The ORDER BY clause allows the objects or values that are returned by the query to be ordered.
The query BNF for the order by clause.
This
OrderByClauseFactory creates a new OrderByClause when the portion of the
query to parse starts with ORDER BY.An orderby_item must be one of the following:
A
state_field_path_expression that evaluates to an orderable
state field of an entity or embeddable class abstract schema type designated in the SELECT clause
by one of the following:
A general_identification_variable
A single_valued_object_path_expression
A state_field_path_expression that evaluates to the same
state field of the same entity or embeddable abstract schema type as a state_field_path_expression in the SELECT clause
A result_variable that refers to an orderable item in the SELECT
clause for which the same result_variable has been specified.This enumeration lists all the possible choices for ordering nulls in an item.
This enumeration lists all the possible choices for ordering an item.
The query BNF for the order by item expression.
This
OrderByItemFactory creates a new OrderByItem.JPA scripting API implementation.
OrderCorrection annotation may be specified together with OrderColumn annotation.
The OrderCorrectionType enum is used with OrderCorrection annotation
that could be applied together with OrderColumn annotation.
In a hierarchical query, if the rows of siblings of the same parent need to be ordered, then the
ORDER SIBLINGS BY clause should be used.The query BNF for the order siblings by clause.
This
OrderSiblingsByClauseFactory creates a new OrderSiblingsByClause when
the portion of the query to parse starts with ORDER SIBLINGS BY.The OR logical operator chains multiple criteria together.
This
OrExpressionFactory creates a new OrExpression when the portion of the query
to parse starts with OR.Use this type of MarshalRecord when the marshal target is an OutputStream and the
XML should not be formatted with carriage returns or indenting.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
Purpose: Allow a semi-generic way of creating packages.
INTERNAL:
Represents the the package level annotations from a specific package.
This class performs package renaming.
Marker interface for queries returning paged results
Finds out if an entity field is pageable and validates paging parameters.
Finds out if a named query is pageable and validates paging parameters.
FeatureResponseBuilder implementation used for pageable collections.
Parameter delimiter char hint values.
This visitor calculates the type of an input parameter.
Parser type property values.
Parser type property values.
Partitioning is used to partition the data for a class across multiple difference databases
or across a database cluster such as Oracle RAC.
A Partitioning is used to partition the data for a class across multiple difference databases
or across a database cluster such as Oracle RAC.
JPA scripting API implementation.
PUBLIC:
A PartitioningPolicy is used to partition the data for a class across multiple difference databases
or across a database cluster such as Oracle RAC.
The query BNF for a pattern value.
Purpose: A tool used to provide performance monitoring information in a server environment.
Purpose: A tool used to provide high level performance profiling information.
A wrapper around the JPA and JAXB artifacts used to persist an application.
Purpose: This is the default copy policy when weaving is used.
Manages the PersistenceContexts that are used by a JPA-RS deployment.
This is the EclipseLink EJB 3.0 provider
This provider should be used by JavaEE and JavaSE users.
Persistence units catalog resource (JPARS version 2.0 and above).
Deprecated.
Use
PersistenceResource instead.JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
The class defines EclipseLink persistence unit property names.
Metadata catalog resource in JPARS version less than 2.0.
Deprecated.
Use
PersistenceUnitResource instead.Purpose: Provides Pervasive SQL DBMS specific behavior.
PessimisticLock hint values.
Description: This policy is used to configure bean level pessimistic locking feature.
PinnedPartitionPolicy pins requests to a single connection pool.
JPA scripting API implementation.
PUBLIC:
PinnedPartitionPolicy pins requests to a single connection pool.
INTERNAL:
Helper class - tracks argument's original position as well as re-ordered position
Used by PLSQLrecord and PLSQLStoredProcedureCall
PUBLIC: Marker interface for Oracle PL/SQL Collections (Nested Tables and Varrays)
PUBLIC: describe an Oracle PL/SQL Cursor type
JPA scripting API implementation.
A PLSQLParameter annotation is used within a
NamedPLSQLStoredProcedureQuery or PLSQLRecord annotation.
JPA scripting API implementation.
PUBLIC: describe an Oracle PL/SQL Record type
A PLSQLRecord annotation is used to define a database PLSQL RECORD type.
A PLSQLRecords annotation allows the definition of multiple
PLSQLRecord.
Purpose: Used to define a platform independent function call.
Purpose:
Generates an Anonymous PL/SQL block to invoke the specified Stored Procedure
with arguments that may or may not have JDBC equivalents.
JPA scripting API implementation.
A PLSQLTable annotation is used to define a database PLSQL TABLE type.
A PLSQLRecords annotation allows the definition of multiple
PLSQLTable.
Support the Pointbase database.
Purpose: This class is used to populate example data into the database, it allows for circular references to be resolved.
Purpose: Provides Postgres specific behavior.
This adapter alters the way the JAXBContext handles relationships for an existing persistence unit.
This listener is used for crating XML mappings for weaved fields.
The PrimaryKey annotation allows advanced configuration of the Id.
JPA scripting API implementation.
JPA scripting API implementation.
A PrivateOwned annotation is used to specify a relationship is privately
owned.
Purpose: Any information stored for a profile operation.
Profiler type persistence property values.
Purpose: Maintain all of the EclipseLink configuration information for a system.
Purpose: Interface used to support caching the project generated from metadata
avoiding costs associated processing the same metadata over multiple deployments.
Purpose: Allow for a class storing a TopLink project's descriptors (meta-data) to be generated.
Annotation for user defined properties.
A static utility class that handles parsing a String
"key=value,key1=value1...." and calls an appropriate set[key]([value]) method
on the provided instance.
A representation of a Property in the
type of a data object.Annotation for a user defined property.
INTERNAL:
JPA scripting API implementation.
Purpose: Generic association object.
The query BNF for a qualified identification variable expression.
Purpose:
This policy defines the configuration options for a Query By Example query.
Purpose: This exception is used for any problem that is detected with a query.
INTERNAL: English ResourceBundle for QueryException messages.
JPA scripting API implementation.
The class defines EclipseLink query hints.
Purpose: Define a Java appropriate alias to a database field or function.
This class is used to wrap collection of Query objects
Purpose:
Provide a very simple low overhead means for measuring query executions, and cache hits.
This object contains the cursor position within the parsed tree and within each of the
Expression from the root to the deepest leaf.Purpose:
Query redirection allows for a named or parameterized query (or finder) to dynamically determine how the query is to be executed based on the arguments.
Purpose:
The purpose of this class is to provide the query redirector with some helper methods for
general EclipseLink operations (such as checking a query against the cache) which may not
occur because the query is being redirected.
Redirectors allow EclipseLink queries to be intercepted and pre/post processed or redirected.
JPA scripting API implementation.
Query resource.
Deprecated.
Use
QueryResource instead.PUBLIC:
A QueryResultsCache policy dictates how a query's results will be cached.
Purpose: An generic query sequence mechanism.
Defines the specification for a call to a JCA interaction that uses a query string.
Query type hint values.
Represent a specific range partition.
PUBLIC:
Represent a specific range partition.
JPA scripting API implementation.
RangePartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's id, location, or tenant.
JPA scripting API implementation.
PUBLIC:
RangePartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's id, location, or tenant.
Range variable declarations allow the developer to designate a "root" for objects which may not
be reachable by navigation.
The query BNF for a range variable declaration expression.
This
RangeVariableDeclaration creates a new RangeVariableDeclaration.Purpose:
Concrete class for all read queries involving a collection of objects.
Specifies the direction in which the hierarchy is traversed in a
hierarchical query.
This class is used to wrap collection of records returned
by a JPA read all query and includes paging links.
Makes the ReadAllQueryResultCollection class available to JPA-RS JAXB context.
Purpose: The read connection pool is used for read access through the server session.
Purpose:
Concrete class for all read queries involving a single object.
The ReadOnly annotation is used to specify that a class is read only.
Purpose:
Abstract class for all read queries.
Annotation for org.eclipse.persistence.mappings.TransformationMapping.
JPA scripting API implementation.
This interface defines the public interface for the EclipseLink DatabaseRecord (was Record),
and the other record types XMLRecord, EISRecord.
The
RecordConverter interface allows conversion of an adapter
specific record.ReferenceAdapter<T extends org.eclipse.persistence.internal.jpa.rs.weaving.PersistenceWeavedRest>
ReferenceAdapterV2<T extends org.eclipse.persistence.internal.jpa.rs.weaving.PersistenceWeavedRest>
Reference adapter used in JPARS V2.
Purpose:
In an object-relational data model, structures reference each other through "Refs"; not through foreign keys as
in the relational data model.
Purpose: This class is a configuration property used to specify
What type of Referenes EclipseLink will use when referencing Entities
within the Persistence Context / UnitOfWork.
The REGEXP condition is used to specify a search for a pattern.
The query BNF for a REGEXP expression.
This
RegexpExpressionFactory creates a new RegexpExpression when the portion of the
query to parse starts with REGEXP.Purpose: EclipseLink has been designed to take advantage of the similarities between
relational databases and objects while accommodating for their differences, providing an object
oriented wrapper for relational databases.
INTERNAL
All mappings which can be added to org.eclipse.persistence.mappings.Descriptor must
implement this interface.
Purpose: Contains relation table functionality
that was originally defined in ManyToManyMapping
and now is shared with OneToOneMapping.
INTERNAL:
Purpose: Provide a CommandManager implementation for cache coordination.
Instances of this exception are raised if a problem is detected in the
RemoteCommandManager (RCM) feature.
INTERNAL:
English ResourceBundle for RemoteCommandManagerExceptionResource messages.
Remote JPA protocol persistence property values.
Purpose: Provide transparent remote three-tiered replacation support.
ReplicationPartitioning sends requests to a set of connection pools.
JPA scripting API implementation.
PUBLIC:
ReplicationPartitioningPolicy sends requests to a set of connection pools.
Purpose: Query for information about a set of objects instead of the objects themselves.
Purpose: A single row (type) result for a ReportQuery
Entry class for implementing Map interface.
This class is used to wrap collection of records returned by
a JPA report query and includes paging links.
Makes the ReportQueryResultCollection class available to JPA-RS JAXB context.
This class is used to wrap collection of records returned by a JPA report query.
This class is used to wrap collection of attributes of a record returned by a JPA report query.
Makes the ReportQueryResultListItem class available to JPA-RS JAXB context.
Makes the ReportQueryResultList class available to JPA-RS JAXB context.
This class contains constants used in JPARS.
RestCollectionAdapter<T extends org.eclipse.persistence.internal.jpa.rs.weaving.PersistenceWeavedRest>
Collections adapter used in JPARS V2.
Collection fields annotated by this annotation support pagination in JPARS service.
This annotation annotation allows the definition of multiple
RestPageableQuery.
Defines a pageable query.
JDBC ResultSet concurrency hint values.
Purpose:
Concrete class to perform read using raw SQL and the SQLResultSetMapping.
JDBC ResultSet type hint values.
Result type hint values.
A result variable may be used to name a select item in the query result.
The query BNF for a result variable expression.
This
ResultVariableFactory creates a new ResultVariable when the portion of the
query to parse starts with or without AS.Purpose:
Allows for INSERT or UPDATE operations to return values back into the object being written.
INTERNAL:
A ReturnInsert annotation allows for INSERT operations to return values back
into the object being written.
JPA scripting API implementation.
A ReturnUpdate annotation allows for UPDATE operations to return values back
into the object being written.
This class exists on on the client side which talks to remote session controller through
RMI connection.
This class exists on on the client side which talks to remote session controller through
RMI connection.
Defines the public methods remote connection can invoke on the remote session controller.
Defines the public methods remote connection can invoke on the remote session controller.
RemoteSessionController sits between the remote session and the session.
RemoteSessionController sits between the remote session and the session.
Purpose: Provide an RMI transport implementation for RCM.
RoundRobinPartitioning sends requests in a round robin fashion to the set of connection pools.
JPA scripting API implementation.
PUBLIC:
RoundRobinPartitioningPolicy sends requests in a round robin fashion to the set of connection pools.
JPA scripting API implementation.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Configures the persistence unit for debugging.
Server platform for SAP NetWeaver AS Java 7.1 (including EhP 1), 7.2 and
follow-up releases.
TransactionController implementation for SAP NetWeaver AS Java 7.1 (including
EhP 1), 7.2 and follow-up releases.
Purpose: Build a DOM from SAX events.
The query BNF for a scalar expression.
INTERNAL:
Purpose: Interface that can be optionally implemented to resolve the
value for the schemaLocation attribute of generated imports and includes when generating schemas.
Purpose: Define all user level protocol for development time database manipulation.
A schema per tenant multitenant policy.
Purpose: Interface that can be optionally implemented to resolve imported and included schemas.
Purpose: Allow the contained schema resolver to resolve a schema based on a given namespace and schema location, and
return either the resolved schema source or null, depending on whether the schema had been processed previously.
INTERNAL:
PUBLIC:
ScrollableCursorPolicy allows for additional options to be specified for ReadAllQuery or DataReadQuery.
Purpose:A change summary is used to record changes to DataObjects.
Purpose: Generate Java interfaces and implementation classes from a list of SDO Type objects.
Purpose: Optionally user can implement this interface to provide their own extra content
to the generated source files.
Purpose: A custom classloader used to dynamically create classes as needed.
Purpose: Maintain constants in one class
Purpose:
A helper class for making deep or shallow copies of DataObjects.
Purpose: Implementation of XMLUnmarshalListener used when unmarshalling XML to XMLDocuments
Purpose: The implementation of commonj.sdo.helper.DataFactory
Purpose: Helper to provide access to SDO Data Factory.
Purpose: Helper to provide access to SDO Data Factory.
Purpose:A data graph is used to package a graph of
data objects along with their
metadata, that is, data describing the data.
Purpose: A helper class for performing data conversions.
Purpose: A helper class for checking deep or shallow equality of DataObjects.
Purpose:
This class provides an implementation of EclipseLinkException specific to the EclipseLink SDO (Service Data Objects) API.
INTERNAL:
Purpose:
Purpose: A wrapper class for handling cases when the domain object attributes are
to be accessed thru the accessor methods that are called "get" and "set".
This class provides a mechanism to obtain the EclipseLink implementation of various SDO runtime
classes based on a given SDO class/interface.
Purpose:
This class represents a local HelperContext.
Strategy for
HelperContext creation.Purpose: Implementation of XMLMarshalListener used when marshalling DataObjects to XML
Purpose: A wrapper class for handling cases when the domain object attributes are
to be accessed thru the accessor methods that are called "get" and "set".
Purpose:A representation of a Property in the
type of a data object.INTERNAL:
Purpose SDOSchemaGenerator generates an XSD (returned as a String)
from a list of SDO Type objects.
Purpose: A setting encapsulates a Property and a corresponding single value of the property's type.
This class provides the list of System properties that are recognized by EclipseLink SDO component.
Purpose: Helper to provide access to declared SDO Types.
Purpose: Helper to provide access to declared SDO Types.
Purpose: Helper to provide access to declared SDO Types.
Purpose: Called from XSDHelper define methods to generate SDO Types from a Schema
Purpose: Called during XMLHelper load methods when there is unknown content in an XML document.
Purpose: Implementation of XMLUnmarshalListener used when unmarshalling XML to XMLDocuments
Purpose: Common functions in support of SDO.
Wrapper for XML datatypes.
Purpose: Represents an XML Document containing a tree of DataObjects.
Purpose: Helper to transform XML documents into DataObects and DataObjects into XML documents.
Purpose: Helper to XML documents into DataObects and DataObjects into XML documents.
Purpose: Helper to XML documents into DataObects and DataObjects into XML documents.
Purpose: Provides access to additional information when the Type or Property is defined by an XML Schema (XSD).
Purpose: Provides access to additional information when the Type or Property is defined by an XML Schema (XSD)..
Purpose: Provides access to additional information when the Type or Property is defined by an XML Schema (XSD)..
JPA scripting API implementation.
The SELECT clause queries data from entities.
The query BNF for the select clause.
This
SelectClauseFactory creates a new SelectClause when the portion of the
query to parse starts with SELECT.
Purpose: An implementation of the OptimisticLockingPolicy interface.
The query BNF for a select expression.
A
SELECT query is an operation that retrieves data from one or more tables or
views.The query BNF for the select statement.
This
SelectStatementFactory creates a new SelectStatement when the portion of the
query to parse starts with SELECT.FeatureResponseBuilder implementation generating 'self' and 'canonical' links.
This helper is used by
AbstractSemanticValidator in order to retrieve JPA information.A sequence is a heterogeneous list of
properties and corresponding values.
Purpose: Abstract class to define sequencing.
Purpose: Allow a generic way of creating sequences on the different platforms,
and allow optional parameters to be specified.
In order to mark a domain object as being a Sequenced Object it must
implement this interface.
JPA scripting API implementation.
Purpose: Sequence definition Native Sequence object.
Purpose: Define an interface to control sequencing functionality.
INTERNAL:
Interface to hold onto a DescriptorEvents within a project so they can be rebuilt after serialization.
A SerializedConverter is used to serialize an object's value into a database binary, character, or XML field.
A TypeConverters annotation allows the definition of multiple SerializedConverter.
SerializedObject annotation is used to set an
org.eclipse.persistence.descriptors.SerializedObjectPolicy on an Entity or MappedSuperClass.
Purpose: The serialized object converter can be used to store an arbitrary object or set of objects into a database binary or character field.
SerializedObjectPolicy (SOP) could be set on a non-aggregate descriptor.
Generic serializer interface.
Purpose: A single session that supports multiple user/clients connection at the same time.
Basic logging class that provides framework for integration with the application
server log.
PUBLIC:
This is the interface describing the behavior for ServerPlatformBase, and any other
class that wants to provide behavior for a server.
PUBLIC:
Implementation of org.eclipse.persistence.platform.server.ServerPlatform
A generic interface that allows implementors to try to detect which platform is currently being executed on.
A utility class to interact with ServerPlatforms.
Implementation of Server
INTERNAL:
The public interface should be used.
Purpose: Encapsulate the information that uniquely identifies a specific
remote command service instance.
JPARS service version.
Purpose: Define the EclipseLink session public interface.
Purpose: Provide a single view to a TopLink session that transparently accesses multple databases.
PUBLIC:
This interface is to allow extra customization on an EclipseLink Session
Purpose: Encapsulate the information provided with session events.
Purpose: To provide a trivial implemetation of SessionEventListener.
Purpose: Used to support session events.
Purpose: Used to support session events.
Helper class to simplify the development and generation of code that accesses
TopLink through the SessionManager (sessions config XML).
INTERNAL:
English ResourceBundle for SessionLoaderExceptionResource messages.
SessionLog is the ever-so-simple interface used by
EclipseLink to log generated messages and SQL.
SessionLogEntry is a simple container object that holds
all the information pertinent to an EclipseLink logging event.
Purpose: Global session location.
Purpose: This interface defines the link between the Session and the PerformanceProfiler tool.
Adapter class for SessionProfiler interface.
Generic tuning interface.
Setting objects are used to control the order in which the
mappings for Sequenced Objects are processed.
The query BNF for a simple arithmetic expression.
The query BNF for a simple case expression.
The query BNF for a simple conditional expression.
The query BNF for a simple entity expression.
The query BNF for a simple entity or value expression.
The FROM clause of a query defines the domain of the query by declaring identification
variables.
This class is used to wrap collection of homogeneous simple java type attributes, such as
Strings, Integers, etc..., and MUST NOT be used to wrap collection of attributes with the type
that is assignable from PersistenceWeavedRest.
Makes the SimpleHomogeneousList class available to JPA-RS JAXB context.
The query BNF for a result variable expression.
The SELECT statement queries data from entities.
The query BNF for the simple select clause.
The query BNF for a simple select expression.
BNFL
subquery ::= simple_select_clause subquery_from_clause [where_clause] [groupby_clause] [having_clause]This
SimpleSelectStatementFactory creates a new SimpleSelectStatement when the
portion of the query to parse starts with SELECT.Marker interface for queries returning single results.
This class is used to wrap collection of attributes returned by the single-result JPA report query.
Makes the SingleResultQueryList class available to JPA-RS JAXB context.
Single result query resource.
Deprecated.
Use
SingleResultQueryResource instead.The result of single result query.
Makes the SingleResultQueryResult class available to JPA-RS JAXB context.
A single table "striped" multitenant policy.
The query BNF for a simple valued object path expression.
The query BNF for a single valued path expression.
The SIZE function returns an integer value, the number of elements of the collection.
This
SizeExpressionFactory creates a new SizeExpression when the portion of the
query to parse starts with SIZE.A
SnapshotCloneListIterable returns a list iterator on a
"snapshot" of a list, allowing for concurrent access to the original list.provide access to "internal" constructor
This class is used to construct expressions that use Oracle Spatial operators
PUBLIC:
A utility class used to set parameters on spatial operators within TopLink's
expression framework.
Provides SQL Anywhere specific behaviour.
Purpose: Used as an abstraction of an SQL call.
Purpose:
An abstract superclass that represents the commonalities between the main
result types of the SQLResultSetMapping
JPA scripting API implementation.
Purpose:
Concrete class to represent the SQLResultSetMapping structure as defined by
the EJB 3.0 Persistence specification.
Purpose: Provides SQL Server specific behavior.
The SQRT function takes a numeric argument and returns a double.
This
SqrtExpressionFactory creates a new SqrtExpression when the portion of the
query to parse starts with SQRT.
Purpose: An abstract class providing default sequence behavior.
Default tuner.
A
START WITH clause is optional and specifies the root row(s) of the hierarchy.The query BNF for the
START WITH clause.This
StartWithClauseFactory creates a new StartWithClause when the portion
of the query to parse starts with START WITH.A
single_valued_association_field is designated by the name of an association-field
in a one-to-one or many-to-one relationship.The query BNF for a state field path expression.
This
StateFieldPathExpressionFactory is meant to handle the parsing of a portion of the
query when it's expected to be a state field path.
Description: This is the static weave command line processing class that verifies command options and invokes
StaticWeaveProcessor to statically weave the classes.
Description: This is the static weave ant task definition class that verifies the value of specified attributes and invokes
StaticWeaveProcessor to weave classes.
Description: This class provides the implementation of class transformer by leveraging on the following existing APIs,
PersistenceUnitProcessor.processORMetadata() - get class descriptor.
Description: The StaticWeaveProcessor controls the static weaving process.
Purpose: Used to define a platform independent function call.
Purpose: Allow a semi-generic way of creating store function.
Purpose: Used to define a platform independent procedure call.
Purpose: Allow a semi-generic way of creating stored procedures.
Purpose: To generate StoredProcedures from EclipseLink Projects
A StoredProcedureParameter annotation is used within a
NamedStoredProcedureQuery annotation.
JPA scripting API implementation.
Simple
StreamingOutput implementation that uses the provided
JAXBContext to marshal the result when requested to either XML or
JSON based on the accept media provided.The query BNF for a string expression.
A string literal is enclosed in single quotes.
The query BNF for a string literal.
This
StringLiteralFactory is responsible to parse a sub-query starting with a single quote.The query BNF for a string primary expression.
Struct types are extended object-relational data-types supported by some databases.
JPA scripting API implementation.
A StructConverter is a special type of converter that handles the conversion of a specific
database Struct type.
JPA scripting API implementation.
PUBLIC:
A StuctConverter can be added to a DatabasePlatform
It allows custom processing dealing java.sql.Struct types
When added to the DatabasePlatform:
1.
A StructConverters annotation allows the definition of multiple
StructConverter.
This class contains predefined StructConverter types.
Struct types are extended object-relational data-types supported by some databases.
JPA scripting API implementation.
Purpose:
A structure is an object-relational user-defined data-type or object-type.
This expression wraps a sub-expression within parenthesis.
This type represents a AttributeNode of an EntityGraph that corresponds to a
Managed Type.
The query BNF for a subquery expression.
The query BNF for the from clause defined in a subquery.
The query BNF for an identification variable declaration expression defined
in a sub-select expression.
The second and third arguments of the SUBSTRING function denote the starting position and
length of the substring to be returned.
This
SubstringExpressionFactory creates a new SubstringExpression when the
portion of the query to parse starts with SUBSTRING.One of the four binary operators.
One of the aggregate functions.
This
SumFunctionFactory creates a new SumFunction when the portion of the query
to parse starts with SUM.Purpose: Provides Sybase ASE specific behavior.
Symfoware Server
http://wiki.eclipse.org/EclipseLink/Development/Incubator/Extensions/SymfowarePlatform
Test results: http://wiki.eclipse.org/EclipseLink/Development/DatabasePlatform/SymfowarePlatform/TestResults
Contributed by: Fujitsu Ltd.
Contributed under bug: 288715
http://wiki.eclipse.org/EclipseLink/Development/Incubator/Extensions/SymfowarePlatform
Test results: http://wiki.eclipse.org/EclipseLink/Development/DatabasePlatform/SymfowarePlatform/TestResults
Contributed by: Fujitsu Ltd.
Contributed under bug: 288715
Purpose: Generate synchronization listener objects of the appropriate type.
This class provides the list of System properties that are recognized by EclipseLink.
JPA scripting API implementation.
Purpose: This class is responsible for creating the tables defined in the project.
Purpose: Allow for a class storing a TopLink table creator's tables (meta-data) to be generated.
Purpose: Allow a generic way of creating tables on the different platforms.
Defines a table expression.
The query BNF for a table expression.
This
TableExpressionFactory creates a new TableExpression.JPA scripting API implementation.
Purpose: Provides the functionality to support a TABLE_PER_CLASS
inheritance strategy.
A table per tenant multitenant policy.
Purpose: Defines sequencing through using a SEQUENCE table.
Purpose: Allow a generic way of creating sequences on the different platforms,
and allow optional parameters to be specified.
Defines a table expression.
The query BNF for a table declaration.
This
TableVariableDeclarationFactory creates a new TableVariableDeclaration.Target database persistence property values.
Target server persistence property values.
JPA scripting API implementation.
Tenant discriminator column(s) are used with a SINGLE_TABLE multitenant
strategy.
JPA scripting API implementation.
A TenantDiscriminatorColumns annotation allows the definition of multiple
TenantDiscriminatorColumn.
A tenant table discriminator is used with a TABLE_PER_TENANT multitenant
strategy.
JPA scripting API implementation.
An enum that is used within the TenantTableDiscriminator annotation.
A TimeOfDay annotation is used to specify a specific time of day using a
Calendar instance which is to be used within an OptimisticLocking annotation.
JPA scripting API implementation.
Purpose: Used to allow a single version timestamp to be used for optimistic locking.
Purpose: Provides TimesTen 7 specific behavior.
Database platform for the TimesTen database product.
PUBLIC:
A CacheInvalidationPolicy which allows objects to live for a specific amount of time
after they are read.
A token is used for processing an XPath Expression
into postfix notation via OPStack.
INTERNAL:
English ResourceBundle for TransactionException messages.
Transformation is an optional annotation for org.eclipse.persistence.mappings.TransformationMapping.
JPA scripting API implementation.
Purpose: A transformation mapping is used for a specialized translation between how
a value is represented in Java and its representation on the databae.
Purpose: To Provide API to the TransformationMappingChangeRecord.
This class is building properties from write transformers.
Provides return type from write transformation method.
JPA scripting API implementation.
PUBLIC:
This class is used by our JPA annotation processing to discover which annotations may coexist with a
jakarta.persistence.Transient annotation.
INTERNAL:
org/eclipse/persistence/internal/remote/TransporterDefaultFactory.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl
Thursday, May 3, 2001 1:36:59 PM EDT
INTERNAL:
org/eclipse/persistence/internal/remote/TransporterHelper.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl
Thursday, May 3, 2001 1:36:59 PM EDT
INTERNAL:
org/eclipse/persistence/internal/remote/TransporterHolder.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl
Thursday, May 3, 2001 1:36:59 PM EDT
Purpose: Provide an abstract class that offers a common API to handling
remote command connections.
Returns an expression that allows to treat its base as if it were a subclass of the class
returned by the base.
The query BNF for a
TREAT expression.This
TreatExpressionFactory creates a new TreatExpression when the portion of the
query to parse starts with TREAT.The TRIM function trims the specified character from a string.
The possible ways to trim the string.
This
TrimExpressionFactory creates a new TrimExpression when the portion of the
query to parse starts with TRIM.Tuning persistence property values.
A representation of the type of a
property of a data object.Purpose: Type conversion converters are used to explicitly map a database type to a
Java type.
The TypeConverter annotation is used to specify an EclipseLink
org.eclipse.persistence.mappings.converters.TypeConversionConverter for modification
of the data value(s) during the reading and writing of a mapped attribute.
JPA scripting API implementation.
A TypeConverters annotation allows the definition of multiple TypeConverter.
Purpose: Generic association object.
Purpose: Allow for Oracle 8 object-relational user defined type to be created.
An entity type expression can be used to restrict query polymorphism.
The query BNF for a type expression.
This
TypeExpressionFactory creates a new TypeExpression when the portion of the
query to parse starts with TYPE.Look up a Type given the uri and typeName or interfaceClass.
INTERNAL:
Purpose: Provides a wrapper for a java type to be used when creating a JAXB context.
Purpose: Allow for tabels of Oracle 8 object-relational user defined type to be created.
PUBLIC:
Integrates with Oracle Universal ConnectionPool's data affinity support.
Purpose: Defines sequencing through using a singleton sequence table.
Purpose: Creates / drops an unary sequence table:
the name of the table is sequence name; its only field is named unarySequenceCounterFieldName
Purpose: UnidirectionalOneToManyMapping doesn't have 1:1 back reference mapping.
The UNION clause allows the results of two queries to be combined.
The query BNF for the order by clause.
This
UnionClauseFactory creates a new UnionClause when the portion of the
query to parse starts with UNION, INTERSECT or EXCEPT.UnionPartitioning sends queries to all connection pools and unions the results.
JPA scripting API implementation.
PUBLIC:
UnionPartitionPolicy sends queries to all connection pools and unions the results.
JPA scripting API implementation.
Purpose: Define a unique key constraint for a table.
Purpose: To allow object level transactions.
Defines the ordering of updates and deletes of a set of the same entity type during a commit or flush operation.
Purpose: To Provide API to the UnitOfWorkChangeSet.
This expression contains a portion of the query that is unknown to the parser.
This
UnknownExpressionFactory creates a new UnknownExpression when the portion of
the query to parse is unknown.Purpose:Provide an interface that can be implemented for handling
unmapped content during unmarshal operations with SAXPlatform.
INTERNAL:
Purpose: Used in conjunction with XMLAnyObject/CollectionMapping and XMLCompositeObject/CollectionMapping
to specify when (if at all) to keep parts of the unmarshalled document as nodes.
These are properties that may be set on an instance of Unmarshaller.
PUBLIC:
A Query Class used to perform a bulk update using TopLink's expression framework.
This is the update clause of the update statement.
The query BNF for the update clause.
This
UpdateClauseFactory creates a new UpdateClause when the portion of the query
to parse starts with UPDATE.The
new_value specified for an update operation must be compatible in type with the
field to which it is assigned.The query BNF for the update item expression.
This
UpdateItemFactory creates a new UpdateItem.The query BNF for a state field path expression used in an update item.
This
UpdateItemStateFieldPathExpressionFactory is meant to handle the parsing of a
portion of the query when it's expected to be a state field path.Purpose:
Used for updating existing objects into the database.
The UPDATE clause of a query consists of a conditional expression used to select objects
or values that satisfy the expression.
The query BNF for the update statement.
This
UpdateStatementFactory creates a new UpdateStatement when the portion of the
query to parse starts with UPDATE.The UPPER function converts a string to upper case and it returns a string.
This
UpperExpressionFactory creates a new UpperExpression when the portion of the
query to parse starts with UPPER.Defines a primary key generator that may be
referenced by name when a generator element is specified for
the
GeneratedValue annotation.JPA scripting API implementation.
A UuidGenerators annotation allows the definition of multiple UuidGenerator.
Purpose: This exception is used if incorrect state or method arguments are detected
in a general TopLink object.
INTERNAL:
English ResourceBundle for ValidationException messages.
Detects external Bean Validation configuration.
An identification variable qualified by the
VALUE operator is a path
expression.This
ValueExpressionFactory creates a new ValueExpression when the portion of the
query to parse starts with VALUE.
Purpose: Act as a place holder for a variable that required a value holder interface.
Purpose: Interface to allow lazy loading of an object's relationships from the database.
Represent a specific value partition.
JPA scripting API implementation.
ValuePartitioning partitions access to a database cluster by a field value from the object,
such as the object's location, or tenant.
JPA scripting API implementation.
PUBLIC:
ValuePartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's location, or tenant.
Purpose:
Concrete class to perform a read of a single data value.
Purpose
The ValueStore interface exposes the property model in SDO to pluggable implementers
that wish to wrap their object model in the SDO API.
Variable one to one mappings are used to represent a pointer references
between a java object and an implementer of an interface.
JPA scripting API implementation.
Purpose: Variable one to one mappings are used to represent a pointer references
between a java object and an implementer of an interface.
Purpose: Allow for creation of varray type.
JPA scripting API implementation.
This class stores variables for the version and build numbers that are used
in printouts and exceptions.
Purpose: Used to allow a single version number to be used for optimistic locking.
Purpose: Allow for creation of views.
Specifies that this class contains virtual attributes.
This
JPQLQueryBNF can be used as a virtual BNF, which can wrap another BNF or BNFs and
modify the default behavior.A vpd multitenant policy.
INTERNAL:
This interface defines functionality required by ValueHolders for OneToOneMappings that
have LAZY access weaved into them and use Property (method) based access
The weaving feature adds a paralell valueholder to the class it weaves and uses that valueholder
to control the lazy loading.
PUBLIC:
This is the concrete subclass responsible for representing WebLogic 10 specific behavior.
PUBLIC:
This is the concrete subclass responsible for representing WebLogic9 specific behavior.
PUBLIC:
This is the concrete subclass responsible for representing WebLogic-specific
server behavior.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for WLS JTA
Purpose: TransactionController implementation for WLS JTA
PUBLIC:
This is the concrete subclass responsible for representing WebSphere
6.1-specific server behavior.
PUBLIC:
This is the concrete subclass responsible for representing WebSphere 7 -specific server behavior.
PUBLIC:
This is the concrete subclass responsible for representing WebSphere-specific server behavior.
PUBLIC:
This is the concrete subclass responsible for representing WebSphere-specific server behavior.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for WebSphere
A WHEN predicate is used to calculate a condition and when it's true, its THEN will
be executed.
The query BNF for the when clause of the case expression.
This
WhenClauseFactory creates a new WhenClause when the portion of the query to
parse starts with WHEN.The WHERE clause of a query consists of a conditional expression used to select objects or
values that satisfy the expression.
The query BNF for the where clause.
This
WhereClauseFactory creates a new WhereClause when the portion of the query
to parse starts with WHERE.This "parser/scanner" holds onto the string version of the JPQL query that is parsed into a
parsed tree.
This enumeration determines the type of word that was scanned.
Purpose: The wrapper policy can be used to wrap all objects read from the database in another object.
Purpose:
Used for inserting or updating objects
WriteObjectQuery determines whether to perform a insert or an update on the database.
Use this type of MarshalRecord when the marshal target is a Writer and the
XML should not be formatted with carriage returns or indenting.
Annotation for org.eclipse.persistence.mappings.TransformationMapping.
JPA scripting API implementation.
An optional annotation for org.eclipse.persistence.mappings.TransformationMapping.
Purpose: Wrap a org.eclipse.persistence.platform.xml.XMLNamespaceResolver
and expose it as a oracle.xml.parser.v2.NSResolver.
Purpose: An implementation of XMLParser using Oracle XDK APIs.
Purpose: An implementation of XMLPlatform using Oracle XDK APIs.
Purpose: An implementation of XMLTransformer using Oracle XDK
APIs.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
Purpose: An abstract superclass for XMLAnyObjectMapping and XMLAnyCollectionMapping.
Java class for xml-abstract-null-policy complex type.
Java class for xml-access-methods complex type.
Purpose:This annotation allows the userTo specify accessor methods for
a given property.
Java class for xml-access-order.
Java class for xml-access-type.
Java class for anonymous complex type.
Purpose:The XMLAnyAttributeMapping is used to map to an attribute in an object to any xml attributes contained
on a specific element in the XML Document.
Any collection XML mappings map an attribute that contains a heterogenous collection of
objects to multiple XML elements.
Java class for anonymous complex type.
Any object XML mappings map an attribute that contains a single object to an XML element.
Purpose: Provides an interface through which EclipseLink can allow a user to do
special handling for Binary Data.
Purpose: Provides an interface through which EclipseLink can allow a user to do
special handling for Binary Data.
Java class for anonymous complex type.
Purpose:Provide a mapping for a collection of binary data values that can be treated
as either inline binary values or as an attachment.
Purpose:Provide a mapping for binary data that can be treated as either inline or as
an attachment.
PUBLIC:
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
Wrap the value inside a CDATA section.
PUBLIC:
PUBLIC:
Java class for xml-class-extractor complex type.
A ClassExtractor allows for a user defined class indicator in place of
using xsi:type.
TopLink OXM version of a 1-M mapping.
This class is used to compare if two DOM nodes are equal.
Composite collection XML mappings map an attribute that contains a homogeneous collection of objects
to multiple XML elements.
Composite direct collection XML mappings map a collection of simple types (String, Number, Date,
etc.) to and from a sequence of composite XML nodes.
Composite object XML mappings represent a relationship between two classes.
XMLConstants maintains a list of useful XML constants.
An XMLContext is created based on EclipseLink sessions or projects and can then
used to create instances of XMLMarshaller, XMLUnmarshaller and XMLValidator.
Purpose: XML conversion exceptions are raised for any problem when
converting Java types to/from XML.
INTERNAL:
Purpose: Conversion interface to allow conversion between object and data types.
The XmlCustomizer annotation is used to specify a class that implements the
org.eclipse.persistence.config.DescriptorCustomizer
interface and is to run against a class descriptor after all metadata
processing has been completed.
Use an XML project for nontransactional, nonpersistent (in-memory) conversions between Java objects and XML documents.
XML Direct Mappings map a Java attribute directly to XML attribute or text node.
The XmlDiscriminatorNode annotation is used to specify the class
indicator field name when using inheritance.
The XmlDiscriminatorValue annotation is used to specify the class indicator for a
given type when using inheritance.
Represents an XML Document containing a tree of DataObjects.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
Purpose: Provide a means of setting nillable on type and package
level, which is not possible with standard XmlElement annotation.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
XmlElementsJoinNodes is used in conjunction with
XmlElements in order to specify the key references for the
targets of the XmlElements annotation.Java class for anonymous complex type.
INTERNAL:
Java class for anonymous complex type.
Java class for anonymous complex type.
TopLink XML mappings make use of XMLFields based on XPath statements to find the relevant
data in an XML document.
Purpose: This mapping provides a means to keep a part of the xml tree as a collection
of DOM elements.
Purpose: This mapping provides a means to keep a part of the xml tree as a DOM element.
A helper to convert XML documents into DataObects and
DataObjects into XML documnets.
Purpose: Provide a way to allow properties with XmlID annotation have different type than java.lang.String.
Defines the specification for a call to a JCA interaction that uses XML.
Java class for anonymous complex type.
This annotation is used to map a back-pointer during the unmarshal operation.
This mapping is used to map a back-pointer.
Java class for anonymous complex type.
Purpose: Provide a means of using annotations to customise the handling of null values
and their xml representation.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
XmlJoinNode is used in conjunction with
XmlKey to specify a reference mapping.Java class for anonymous complex type.
XmlJoinNodes is a holder for multiple
XmlJoinNode annotations.Java class for anonymous complex type.
XmlKey is used to mark a property as a key, to be referenced using a key-based mapping via
XmlJoinNode.Purpose: Provides an implementation of Converter that can be used to convert a
collection of Objects into a space separated list of Strings and back.
XmlLocation can be used on a property of type Locator, to provide information about
the XML location (line and column number, source location) that the owning object was unmarshalled from.
Format a TopLink LogRecord into a standard XML format.
In OX, the platform determines which parsing method will be used, DOM vs SAX.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
INTERNAL
All mappings which can be added to org.eclipse.persistence.oxm.XMLDescriptor must
implement this interface.
Purpose: XMLMarshalExceptions are raised when issues are encountered
during XMLMarshaller or XMLUnmarshaller operations.
INTERNAL:
English ResourceBundle for XMLValidationException.
Class used to marshal object to XML.
An implementation of XMLMarshalListener can be set on an XMLMarshaller to provide additional
behaviour during marshal operations.
Java class for xml-marshal-null-representation.
Purpose: This enumeration provides a means of specifying how a null value in a
java object should be marshalled to XML.
A concrete implementation of MetadataSource that can represent the following
metadata input types;
java.io.File
java.io.InputStream
java.io.Reader
java.net.URL
javax.xml.stream.XMLEventReader
javax.xml.stream.XMLStreamReader
javax.xml.transform.Source
org.w3c.dom.Node
org.xml.sax.InputSource
Purpose: Support reading metadata for a persistence unit in an XML format from a URL and if the property is undefined,
it will look for a file.
Java class for xml-named-attribute-node complex type.
A
XmlNamedAttributeNode is a member element of a
XmlNamedObjectGraph.Java class for anonymous complex type.
Purpose: Used to define the boundaries for a marshal or unmarhsal
operation.
Java class for anonymous complex type.
Used to group
XmlNamedObjectGraph annotations.Java class for xml-named-subgraph complex type.
A
XmlNamedSubgraph is a member element of a
XmlNamedObjectGraph.An XmlNameTransformer allows for a user defined class to transform names.
Interface used when converting from XML to Java names.
INTERNAL
All nillable mappings which can be added to org.eclipse.persistence.oxm.XMLDescriptor must
implement this interface.
The default policy is AbstractNullPolicy.
The default policy is AbstractNullPolicy.
Implementation of the org.w3c.dom.NodeList interface
Java class for xml-ns-form.
Java class for anonymous complex type.
Purpose: Provide a means of using annotations to customise the handling of null values
and their xml representation.
Description:
An enum that is used within a Node Null Policy to determine what to marshal for a null node.
We define 3 final instances available to the user (XSI_NIL, ABSENT_NODE(default) and EMPTY_NODE.
We define 3 final instances available to the user (XSI_NIL, ABSENT_NODE(default) and EMPTY_NODE.
TopLink OXM version of a 1-1 mapping.
Purpose: An annotation representing a parameter to a method.
XPath based mapping is what allows an existing object model to be mapped
to an existing XML schema.
Purpose: This annotation is used in conjunction with an XmlElements annotation to
specify an XmlPath for each of the XmlElement annotations in the XmlElements.
XMLPlatform<XML_UNMARSHALLER extends org.eclipse.persistence.internal.oxm.XMLUnmarshaller>
INTERNAL:
INTERNAL:
Purpose: Allow for a EclipseLink Mapping Workbench generated deployment XML project file to be read.
Purpose: Write the deployment XML (object persistence meta-data) for the TopLink project instance to a file.
Java class for xml-properties complex type.
Annotation for user defined properties.
Java class for anonymous complex type.
Annotation for a user defined property.
Purpose: This annotation indicates that a specific property should be flagged as read-only
by EclipseLink.
Purpose: XmlReadTransformer is used to allow the user direct access to the XML in order to populate their
object model.
PUBLIC:
Provides a Record/Map API on an XML DOM element.
Java class for anonymous complex type.
Java class for anonymous complex type.
XMLRoot is used to hold an Object along with the corresponding QName and some other related information.
Purpose: Provides an implementation of XMLConverter to wrap/unwrap objects in an
XMLRoot in order to capture element name information.
Java class for anonymous complex type.
Record for handling simple root elements that have a single text child node,
and are being unmarshalled to a primitive wrapper object.
Java class for anonymous complex type.
Java class for anonymous complex type.
A schema reference for accessing an XML Schema from the class path.
A schema reference for accessing an XML Schema from a file.
Provides a way for a descriptor's reference to its schema to be specified.
A schema reference is used to access a schema in order to validate a
document.
Java class for anonymous complex type.
Java class for anonymous complex type.
Uses JAXB to convert an object to XML.
Provide a mechanism for loading Session configuration XML files.
Use this type of MarshalRecord when the marshal target is an XMLStreamWriter
Java class for anonymous complex type.
Transformation is an optional annotation for org.eclipse.persistence.mappings.oxm.XMLTransformationMapping.
Java class for anonymous complex type.
Java class for anonymous complex type.
Transformation XML mappings are used to create a custom mapping where one or more XML nodes can
be used to create the object to be stored in a Java class's attribute.
Java class for anonymous complex type.
Java class for anonymous complex type.
Subclass of XMLField for fields that are mapped to unions.
Class used to unmarshal XML & JSON to objects.
Class used to unmarshal SAX events to objects.
An implementation of XMLUnmarshalListener can be set on an XMLUnmarshaller to provide additional
behaviour during unmarshal operations.
Class used to validate XML.
Java class for anonymous complex type.
Purpose: Provide a way to allow classes, which contain property annotated with XmlValue to extend classes other than java.lang.Object.
Java class for anonymous complex type.
Used in
XmlVariableNode.type() to
signal that the type be inferred from the signature
of the property.Java class for anonymous complex type.
The XmlVirtualAccessMethods annotation is used to indicate that this class has
been configured to hold virtual properties.
Purpose: XmlVirtualAccessMethodsSchema enumeration is used in conjunction with XmlVirtualAcessMethods
to configure how virtual properties are generated into the schema.
Purpose: This annotation indicates that a specific property should be flagged as write-only
by EclipseLink.
Annotation for org.eclipse.persistence.mappings.oxm.XMLTransformationMapping.
Purpose: Annotation used to wrap multiple XmlWriteTransformer annotations.
Purpose: Perform operations based on SDO XPath against DataObjects.
This singleton provides support for querying DataObjects
via xpath expression where the result is a List containing
one or more simple types or DataObjects.
Defines the specification for a call to a JCA interaction that uses XQuery.
Provides access to additional information when the
Type or Property is defined by an XML Schema (XSD).
INTERNAL:
org/eclipse/persistence/remote/corba/sun/_CORBARemoteSessionControllerImplBase.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from d:/StarTeam/DIDev/Pine/TopLink/DISource/IDLs/CorbaRemoteSessionControllerSun.idl
Thursday, May 3, 2001 1:36:59 PM EDT
INTERNAL:
org/eclipse/persistence/remote/corba/sun/_CORBARemoteSessionControllerStub.java
Generated by the IDL-to-Java compiler (portable), version "3.0"
from CorbaRemoteSessionControllerSun.idl
Monday, November 19, 2001 1:51:44 o'clock PM EST
INTERNAL:
INTERNAL: