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.The
ABS function removes the minus sign from a specified argument and returns
the absolute value, which is always a positive number or zero.INTERNAL
JPA scripting API implementation.
This
IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed, which means this formatter can only be used when the
StateObject was created by parsing a JPQL query because it needs to retrieve parsing
information from the corresponding Expression.JPA scripting API implementation.
This abstract implementation of
ICaseExpressionStateObjectBuilder adds support for
creating a CASE expression.JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
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.
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.
The abstract implementation of
IConditionalExpressionStateObjectBuilder that supports the
creation of the conditional expression based on the JPQL grammar defined in JPA 2.0.This builder wraps another builder and delegates the calls to it.
The visitor provides support for finding the possible proposals within a JPQL query at a certain
position.
This helper handles adding proposals within a conditional expression that might be parsed as
a single expression or has a collection of expression, which means the fragment is either
incomplete or invalid.
This visitor retrieves the permitted type from the path expression's parent.
This visitor scans the visited
Expression and determines if a JPQL identifier can be
added ("appended") when the position of the cursor is at the end of the expression.This is used to determine how
AbstractContentAssistVisitor.AppendableExpressionVisitor should perform the check.This helper is used to determine how to add proposals within a collection of expressions.
This visitor retrieves the
CollectionExpression if it is visited.This helpers handles adding proposals for
AbstractConditionalClause.The default implementation of
AbstractContentAssistVisitor.MappingCollector, which simply returns an empty collection.This builder populates a
QueryPosition by traversing the valid portion of the JPQL
query.This visitor determines whether a path expression can be resolved as a fully qualified enum
type and an enum constant.
This
AbstractContentAssistVisitor.MappingCollector returns the possible mappings (non-collection type or
collection type) from a managed type.The various ways of retrieving identification variables from the declaration expression.
This visitor is used when a clause or a compound expression was parsed with a collection of
expressions representing an invalid fragment.
This visitor determines if the visited
Expression is one of the two that represents
an invalid expression.A collector is responsible to retrieve the possible proposals by using the mappings that can
complete a path expression.
This visitor is responsible to create the right
Filter based on the type of the Expression.This
Filter is responsible to filter out the mappings that can't have their type
assignable to the one passed in.This helper helps to add JPQL identifiers for the clauses that make up a query statement and
also chains the clauses within the query.
This visitor determines if an
Expression is in a subquery.This visitor is meant to adjust the corrections stack when traversing an
Expression in
order to increase the list of valid proposals.This helpers handles adding proposals for
WhenClause.INTERNAL:
Abstract metadata converter.
Purpose: Allows customization of how an object is cloned.
JPA scripting API implementation.
Purpose: Maps an attribute to the corresponding database field type.
JPA scripting API implementation.
JPA scripting API implementation.
This
Expression takes care of parsing an expression that encapsulates two expressions
separated by a comma.This
StateObject represents a JPQL expression that has a JPQL identifier followed by
two an encapsulated expression with parenthesis, the two expression are 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.The abstract definition of
EclipseLinkStateObjectVisitor, which implements all the
methods but does nothing.This
ExpressionVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given Expression.This
StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given StateObject.This
EclipseLinkExpressionVisitor traverses up the hierarchy.This
StateObjectVisitor traverses up the hierarchy.JPA scripting API implementation.
This expression handles parsing the identifier followed by an expression encapsulated within
parenthesis.
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.
This state object represents the abstract definition of a
FROM clause, which
is either the FROM clause of the query or of a sub-query expression.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.
The root helper that validates any
AbstractEncapsulatedExpression.The abstract implementation of
AbstractGrammarValidator.AbstractSingleEncapsulatedExpressionHelper which
implements some of the methods since the behavior is the same for all subclasses of
AbstractSingleEncapsulatedExpression.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.
Purpose: Caches objects, and allows their retrieval by their primary key.
Abstract
Enumeration interface implementation for IdentityMap
interface.A node that represents a bytecode instruction.
The abstract definition of a
JPQLGrammar.An abstract implementation of
IJPQLQueryBuilder that parses a JPQL query or any JPQL
fragments and creates the StateObject representation by delegating the creation to an
instance of BasicStateObjectBuilder.The abstract definition of a
IJPQLQueryFormatter, which converts an StateObject
into its string representation that can be used as a real JPQL query.This helper can perform the following operations over a JPQL query:
Calculates the result type of a query:
AbstractJPQLQueryHelper.getResultType();
Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String).
Calculates the possible choices to complete the query from a given
position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int).
Validates the query by introspecting it grammatically and semantically:
AbstractJPQLQueryHelper.validate(),
AbstractJPQLQueryHelper.validateGrammar(),
AbstractJPQLQueryHelper.validateSemantic().
Refactoring support:
AbstractJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the
refactoring operation through a collection of TextEdit objects.
AbstractJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through
the editable StateObject
and once all refactoring operations have been executed, the IJPQLQueryFormatter will
generate a new string representation of the JPQL query.
The abstraction definition of a
StateObject that holds onto a list of children, the
methods defined in ListHolderStateObject are automatically handled here.This factory is responsible to return the right literal expression.
JPA scripting API implementation.
JPA scripting API implementation.
This class represents marshal record behaviour that is common to all XML
platforms.
The abstract definition of a modify statement.
JPA scripting API implementation.
PUBLIC: Description: This node null policy allows for the handling of
various representations of null in XML documents.
JPA scripting API implementation.
An ordering clause allows the objects or values that are returned by the query to be ordered.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
An identification variable followed by the navigation operator (.) and a state field or
association field is a path expression.
An identification variable followed by the navigation operator (.) and a state field or
association field is a path expression.
This
Resolver is responsible to resolve a single path of a path expression (state field
path expression, singled valued object field, or a collection-valued path expression).Base class for persistent unit resources.
JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
Purpose: Contains the implementation of the AbstractQuery interface of
the JPA criteria API.
Base class for query resource.
The abstract definition of a range declaration, which is used to navigate to a "root" object.
Purpose: Define the abstract definition of a record for internal use.
INTERNAL:
NoEntry: This is used to differentiate between the two kinds
of nulls: no entry exists, and the field is actually mapped
to null.
Entry class for implementing Map interface.
The abstract definition of a refactoring
JPA scripting API implementation.
JPA scripting API implementation.
Base class for all resources.
This abstract definition of a builder provides the support for creating expressions defined by a
scalar expression.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.An abstract schema name designates the abstract schema type over which the query ranges.
The SELECT clause denotes the query result.
This state object represents the abstract definition of a
SELECT clause,
which is either the SELECT clause of the top-level query or of a subquery.A query is an operation that retrieves data from one or more tables or views.
This state object represents the select statement, which has at least a
SELECT
clause and a FROM clause.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.The base class for SerializedObjectPolicy.
Abstract Serializer class.
Implementation of org.eclipse.persistence.sessions.Session
The public interface should be used.
Represents the abstract log that implements all the generic logging functions.
The abstract implementation of
ISimpleSelectExpressionStateObjectBuilder that supports
the creation of the select expression based on the JPQL grammar defined in JPA 2.0.This expression handles parsing a JPQL identifier followed by an expression encapsulated within
parenthesis.
This
StateObject represents a JPQL expression that has a JPQL identifier followed by
an encapsulated expression with parenthesis.Base class for all single result query resources.
The abstract definition of a
StateObject.The abstract definition of a builder of a
StateObject hierarchy based on a JPQL fragment
that is manually created.The abstract definition of
StateObjectVisitor, which implements all the methods but does
nothing.The abstract class provides a set of methods to out outputs into the sepcified archive file.
JPA scripting API implementation.
Purpose: Abstract Synchronization Listener class
Description: This abstract class is paired with the
AbstractTransactionController class.
JPA scripting API implementation.
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
StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going
down into each of the children of any given StateObject.This
ExpressionVisitor traverses up the hierarchy.This
StateObjectVisitor traverses up the hierarchy.This
Expression takes care of parsing an expression that encapsulates three expressions
separated by a comma.This state object takes care of parsing an expression that encapsulates three expressions
separated by a comma.
This class represents unmarshal record behaviour that is common to all XML
platforms.
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.INTERNAL:
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Metadata for user specified property access methods and also used with
VIRTUAL access types.
INTERNAL:
Accessor defines the interface used primarily by the assorted
TopLink Sessions to interact with a data store.
Purpose: This class provides a wrapper for an instance of AccessorFactory.
Purpose: Provides Microsoft Access specific behavior.
An additional criteria can be specified at the Entity or MappedSuperclass
level.
JPA scripting API implementation.
JPA scripting API implementation.
Object to hold onto additional criteria metadata.
One of the four binary operators.
TODO:
Processor for computable tasks.
A
MethodVisitor to insert before, after and around advices in methods and constructors.
Purpose: Define a listener for attribute change tracking.
This change Record is used to record the changes for AggregateObjectMapping.
Purpose: Define the Public interface for the Aggregate Change Record.
This change record records the changes for AggregateCollectionMapping.
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.
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.
INTERNAL
Purpose: Define a listener for object change tracking.
Purpose:Two objects can be considered to be related by aggregation if there is a strict
1:1 relationship between the objects.
This interface should be implemented by any node that can be aliased in the select clause.
Purpose: An implementation of the OptimisticLockingPolicy interface.
INTERNAL
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.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.A
MethodVisitor that keeps track of stack map frame changes between AnalyzerAdapter.visitFrame(int, int, Object[], int, Object[]) calls.
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.The
AND logical operator chains multiple criteria together.This filter will "accept" any object that is accept by both of the specified wrapped filters.
INTERNAL
Purpose:Provide a class which is responsible for returning Annotations
from AnnotatedElements.
A node that represents an annotation.
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.
An
AnnotationVisitor that remaps types with a Remapper.INTERNAL:
A visitor to visit a Java annotation.
This visitor allows a subclass to simply override
AnonymousExpressionVisitor.visit(Expression) and perform the
same task for all visited expressions.This visitor allows a subclass to simply override
AnonymousStateObjectVisitor.visit(StateObject) and perform the
same task for all visited ItateObjects.This visitor allows a subclass to simply override
AnonymousStateObjectVisitor.visit(StateObject) and perform the
same task for all visited ItateObjects.Purpose: Implementation of DeferredContentHandler for XMLAnyCollectionMappings.
INTERNAL
INTERNAL:
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.
Defines the meta-data for the Oracle AQ adapter
Connection to Oracle AQ JCA adapter.
Connection factory for AQ JCA adapter.
Defines the meta-data for the Oracle AQ adaptor
Connection spec for AQ JCA adapter.
Interaction spec for AQ JCA adapter.
Provides connection information to an Oracle AQ data source.
Interaction spec for AQ JCA adapter.
Interaction to Oracle AQ JCA adapter.
Interaction spec for AQ JCA adapter.
Platform for Oracle AQ JCA adapter.
Simple indexed record.
Record factory for Oracle AQ JCA adapter.
Transaction to Oracle AQ JCA adapter.
Provides an abstraction to deal with various kinds of URLs that can
be returned by
PersistenceUnitInfo.getPersistenceUnitRootUrl()Abstract base class of all Archives.
This interface should be implemented by users that want to provide a custom way
of dealing with archives that contain persistence units.
This class is written to deal with various URLs that can be returned by
PersistenceUnitInfo.getPersistenceUnitRootUrl()INTERNAL:
This an extended FunctionExpression that allows the argument list to grow after it is created.
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 represents an arithmetic expression, which means the first and second expressions
are aggregated with an arithmetic sign.
This expression simply adds a plus or minus sign to the arithmetic primary expression.
The query BNF for an arithmetic factor expression.
This state object simply adds a plus or minus sign to the arithmetic primary expression.
INTERNAL
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.
An array accessor.
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.
JPA scripting API implementation.
An
ArrayIterator provides a Iterator for an array of objects.PERF: Avoids reflection usage for ArrayList.
Purpose:
In an object-relational data model, structures can contain "Arrays" or collections of other data-types.
PERF: Optimized record implementation using arrays instead of Vector.
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.
JPA scripting API implementation.
Object to hold onto an association override meta data.
INTERNAL:
Attachment is a helper object used by the
QueryOperation to handle binary attachments.INTERNAL:
AttachmentHelper is a helper object used by
the QueryOperation to handle binary attachments.INTERNAL:
INTERNAL:
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine
Specification (JVMS).
Purpose: This provides an abstract class for setting and retrieving
the attribute value for the mapping from an object.
Purpose: Define a listener for attribute change tracking.
PUBLIC:
An AttributeChangeTrackingPolicy allows change tracking at the attribute level of an
object by implementing ChangeTracker.
INTERNAL:
INTERNAL:
Internal helper class that holds details of a persistent attribute.
Purpose: An AttributeGroup represents a set of mappings and nested
AttributeGroups for relationship mappings for an entity type.
Purpose: Provides the implementation for the Attribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
Purpose: Elements stored in AttributeGroup
INTERNAL:
Attribute name prefixes.
INTERNAL:
Attribute name tokenizer.
INTERNAL:
Attribute name tokenizer parser implemented as an
Iterator<String> over individual attribute name tokens.INTERNAL
Represents an AttributeNode of an entity graph.
Concrete JPA AttributeNode class.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto an attribute override meta data.
A proxy class that allows EclipseLink to trigger the deployment of a persistence unit
as an Attribute is accessed in the metamodel.
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.One of the aggregate functions.
INTERNAL
Used as the backup value holder in the unit of work for transparent indirection.
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 wraps an invalid portion of the JPQL query that could not be parsed.
INTERNAL:
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.Generic class for an expression with a base.
An abstract implementation of a
IJPQLQueryFormatter.JPA scripting API implementation.
INTERNAL:
A relational accessor.
Deprecated.
INTERNAL:
A basic collection accessor.
Purpose: Represents a Join to a ElementCollection of basics.
JPA scripting API implementation.
Purpose
Purpose: Represents a Join to a ElementCollection of basics.
Deprecated.
INTERNAL:
A basic collection accessor.
Purpose: Represents a Join to a ElementCollection of basics.
The abstract implementation providing refactoring support for JPQL queries.
A simple implementation of
IQuery.
Purpose: Represents a Join to a ElementCollection of basics.
The default implementation of a
IBuilder, which creates a StateObject
representation of the Expression being
visited.INTERNAL
This class is a helper class providing type information.
Purpose: Provides the implementation for the Basic interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A BatchFetch annotation can be used on any relationship mapping,
(OneToOne, ManyToOne, OneToMany, ManyToMany, ElementCollection, BasicCollection, BasicMap).
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to represent the cascade types specified for a relationship
mapping element.
BatchFetchPolicy defines batch reading configuration.
Enum used with the BatchFetch annotation, or "eclipselink.batch.type" query hint.
For use with a batch SQL query, i.e.
Model class for a batch SQL operation, i.e.
BatchValueHolder is used by the mappings that use indirection when using query optimization (batch reading).
Specify the use of batch writing to optimize transactions with multiple writes,
by default batch writing is not used.
INTERNAL:
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.
Responsible for intialializing Bean Validation.
Responsible for performing automatic bean validation on call back events.
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.Used in conditional expression to determine whether the result of an expression falls within an
inclusive range of values.
INTERNAL
Purpose: Provides a means to configure bidirectional relationship
maintenance for OXM mappings.
Purpose: Implementation of DeferredContentHandler for Binary Mappings.
INTERNAL
INTERNAL:
The query BNF for a boolean expression.
The query BNF for a boolean literal expression.
INTERNAL
The query BNF for a boolean primary expression.
Purpose: Base class extending RemoteConnection for broadcasting RCM protocols: JMS and Oc4jJGroups.
Purpose: Base class transport manager for broadcasting RCM protocols: JMS and Oc4jJGroups.
INTERNAL:
This is for exceptions encountered while extracting or inserting data in byte arrays.
INTERNAL:
Purpose: This class handles all the byte <-> string conversions.
A dynamically extensible vector of bytes.
The Cache annotation is used to configure the EclipseLink object cache.
JPA scripting API implementation.
Purpose: In certain cases the contents of a relationship may be
retrievable from a cache.
Cache coordination protocol persistence property values.
An enum that is used within the Cache annotation.
Defines a wrapper for a primary key (Id) to use as a key in the cache.
Purpose: A fixed size LRU cache
Implements the JPA Cache interface using the EclipseLink cache API through IdentityMapAccessor.
JPA scripting API implementation.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto cache index metadata.
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.
JPA scripting API implementation.
Object to hold onto cache interceptor metadata.
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
Purpose: Container class for storing objects in an IdentityMap.
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.
Object to hold onto cache metadata.
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.
Purpose:
Mechanism used for custom SQL and stored procedure queries.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
INTERNAL:
Object to represent the cascade types specified for a relationship
mapping element.
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.A
CASE predicate is used to calculate a condition and when it's true,
its THEN expression will be executed.INTERNAL
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.INTERNAL:
Defines the meta-data for the Oracle JMS adapter
INTERNAL:
Connection to the Oracle JMS JCA adapter.
INTERNAL:
Connection factory for JMS JCA adapter.
Defines the meta-data for the Oracle JMS JCA connection
INTERNAL:
Provides the behavior of instantiating a JMS ConnectionSpec.
INTERNAL:
Interaction to Oracle JMS JCA adapter.
INTERNAL:
Interaction spec for JMS JCA adapter.
INTERNAL:
Interaction spec for JMS JCA adapter.
INTERNAL:
A simple indexed record.
INTERNAL:
Record factory for the Oracle JMS JCA adapter.
INTRNAL:
Interaction spec for JMS JCA adapter.
INTERNAL:
Interaction spec for JMS JCA adapter.
INTERNAL:
Transaction to Oracle JMS JCA adapter.
Purpose: An implementation of the OptimisticLockingPolicy interface.
A ChangeListener is used to extend a PersistenceContext to react to database sent change
events.
Purpose: This class was designed as a superclass to all possible Change Record types.
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.
This
ChangeSupport is responsible to notifies registered listeners upon changes made
to a StateObject, those changes are either a property has changed (IPropertyChangeListener)
or the content of a list has changed (IListChangeListener).
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.
JPA scripting API implementation.
Object to hold onto change tracking metadata.
An enum that is used within the ChangeTracking annotation.
Provide an interface to allow for custom character escaping behaviour.
Provide an interface to allow for custom character escaping behaviour.
INTERNAL:
Purpose: Class to represent the characters event
Purpose: Class to represent a Choice in a Schema
Allow the unmarshal context to be wrapped.
INTERNAL:
A abstract class accessor.
Purpose: This class maintains information about a generated class and its corresponding interface
INTERNAL:
INTERNAL:
Purpose:
Abstract descriptor class for defining persistence information on a class.
Internal helper class that holds details of a persistent 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.
INTERNAL:
Abstract converter class that parents both the JPA and Eclipselink
converters.
Tagging interface used to mark class as requiring class name conversion during deployment.
A node that represents a class.
A parser to make a
ClassVisitor visit a ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).A
ClassVisitor that remaps types with a Remapper.This
Resolver simply holds onto the actual type since it is already determined.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.
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.
Exception thrown when the constant pool of a class produced by a
ClassWriter is too
large.A visitor to visit a Java class.
INTERNAL: Weaves classes to allow them to support EclipseLink indirection.
A
ClassVisitor that generates a corresponding ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).Behavioral interface saying that there is option to clear contents of the object.
Purpose: Acts as a client to the server session.
INTERNAL:
IdentityMapAccessor subclass for client sessions.
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.
JPA scripting API implementation.
INTERNAL:
Used to store information about CloneCopyPolicy as it is read from XML or
annotations.
Pull together remover state and behavior for subclasses.
A
CloneIterator iterates over a copy of a collection,
allowing for concurrent access to the original collection.Used by
CloneIterator to remove
elements from the original collection; since the iterator
does not have direct access to the original collection.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.
Defines primary key extraction code for use in JPA.
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.A
COALESCE expression returns null if all its arguments evaluate
to null, and the value of the first non-null argument otherwise.INTERNAL
Purpose: to allow on demand conversions of fields which are redefined.
Purpose: This class extends database row to allow for
CobolRedefinedFieldValue
use as a value and for on-demand value extraction.INTERNAL:
INTERNAL:
A
MethodVisitor that approximates the size of the methods it visits.Purpose:This interface can be implemented and used in conjunction with SDOClassGenerator
to write the generated source as desired.
INTERNAL:
A relational collection mapping accessor.
Purpose: Provides the implementation for the CollectionAttribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A proxy class that allows EclipseLink to trigger the deployment of a persistence unit
as an CollectionAttribute is accessed in the metamodel.
Purpose: Define a change event for collection types.
Purpose: This class holds the record of the changes made to a collection attribute of
an object.
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.
Purpose: A CollectionContainerPolicy is ContainerPolicy whose container class
implements the Collection interface.
This
CollectionDeclaration represents a collection member declaration that was
declared in the FROM clause of a SELECT top-level query
or subquery.This
Resolver compares each IType retrieved from the list of Resolvers that were gathered for a given Expression and returns that type if they are all the same type otherwise the IType for
Object is returned.Used for wrapping collection of values or expressions.
A
CollectionExpression wraps many expression which they are separated by spaces
and/or commas.This
StateObject is a temporary object used to store a list of StateObjects.INTERNAL:
Purpose: Contains the implementation of the CollectionJoin interface of the JPA
criteria API.
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.An identification variable declared by a
collection_member_declaration ranges over
values of a collection obtained by navigation using a path expression.INTERNAL
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.This expression tests whether the designated value is a member of the collection specified by the
collection-valued path expression.
JPARS 2.0 collection proxy interface.
Generates a subclass of given collection implementing CollectionProxy interface.
INTERNAL: Sub-component of an
Operation, indicates more than one
return value from the database.Deprecated.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a collection table metadata in an EclipseLink
database table.
This utility class provides utility methods related to collections, iterators and arrays.
This abstract class is used to support JAXBContext creation with a List class.
This
Resolver is responsible to resolve the type of a collection-valued field.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.
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.
Wrapper for collection used in JPARS 2.0.
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.
INTERNAL: Object to process a JPA column into an EclipseLink database field.
JPA scripting API implementation.
Purpose:
Concrete class to represent the ColumnResult structure as defined by
the EJB 3.0 Persistence specification.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a column result metadata.
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
org/eclipse/persistence/internal/remotecommand/corba/sun/CommandDataHelper.java .
org/eclipse/persistence/internal/remotecommand/corba/sun/CommandDataHolder.java .
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.
Purpose: Synchronous and asynchronous propagation of remote commands
INTERNAL:
Purpose: Class to represent the comment event
This class maintains a commit stack and resolves circular references.
This class calculates a commit order for a series of classes
based on the dependencies between them.
This wraps a descriptor with information required to compute an order for
dependencies.
Commit order type persistence property values.
Purpose: Contains the implementation of the CommonAbstractCriteria interface of
the JPA criteria API.
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 =.Only the values of like types are permitted to be compared.
Helper class for code that needs to be shared between AnnotationsProcessor,
MappingsGenerator, SchemaGenerator
PUBLIC: Abstract class for Complex Database types
(e.g.
INTERNAL: a helper class that holds DatabaseType's.
Purpose:
Used to return multiple sets of information from a query.
A Value Object class representing XML Schema's complexType.
INTERNAL:
Object to hold onto complex type meta-data, including PL/SQL records
and collections, as well as advanced Oracle JDBC types.
Purpose: This class represents metadata for composite fields.
A CompositeMember annotation is ignored unless is in composite member persistence unit.
Purpose: This interface defines api for composite fields/records.
INTERNAL:
Abstract class for expression that have exactly two children, such as and/or and relations.
A compound expression has a left and right expressions combined by an identifier.
Purpose: Contains the implementation of the Predicate interface of the JPA
criteria API.
A compound
StateObject has a left and right expressions combined by an identifier.This filter provides a simple framework for combining the behavior of a pair of filters.
Purpose: Contains the implementation of the Selection interface of the JPA
criteria API.
Computable task.
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.The
CONCAT function returns a string that is a concatenation of its arguments.INTERNAL
Factory class to create concrete subclasses of abstract classes.
Purpose: Concurrency deadlock or interupts will raise this exception.
INTERNAL:
English ResourceBundle for ConcurrencyException messages.
INTERNAL:
Provide a concurrent fixed size caching mechanism.
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.PUBLIC:
The base class for connection customization.
Purpose: Used to specify how a client session's should be allocated.
Default value Transactional causes creation of ClientSession,
the other two values - ExclusiveIsolatedClientSession.
INTERNAL:
Purpose: Used to specify how connection should be pooled in a server session.
INTERNAL:
A simple invocation handler for the proxied connection.
Purpose:
Define an interface for supplying TopLink with a
Connection to
a JDBC database.
Purpose: This class provides an implementation of an internal RCM Command.
A constant whose value is computed at runtime, with a bootstrap method.
Used for wrapping constant values.
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.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 item expression.
INTERNAL
This object scans a
DatabaseQuery and checks if it's a constructor query.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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto an entity result metadata.
Purpose: Contains the implementation of the Selection interface of the JPA
criteria API.
Purpose: Provide ability for developers to wrap ValueHolders (Basic Indirection)
Interface used by clients to interact
with the assorted mappings that use
ContainerPolicy.Purpose:
Used to support collections in read queries.
INTERNAL:
This extension can be used to provide additional support to JPQL content assist that is outside
the scope of providing proposals related to JPA metadata.
This object stores the various proposals available for content assist for a certain position
within a JPQL query.
This enumeration determines the type of classes returned by
ContentAssistProposals.classNames().Holds onto the
IType of the enum type and the list of possible enum constants.Use this type of MarshalRecord when the marshal target is a
ContentHandler.
Context<ABSTRACT_SESSION,DESCRIPTOR,FIELD,NAMESPACE_RESOLVER,PROJECT,SESSION,SESSION_EVENT_LISTENER>
JPARS 2.0 contexts catalog.
Purpose: Conversion exceptions such as method or class not defined will raise this exception.
INTERNAL:
English ResourceBundle for ConversionException messages.
Purpose: Contains the conversion routines for some common classes in the system.
A ConversionValue annotation is used within an ObjectTypeConverter.
JPA scripting API implementation.
JPA scripting API implementation.
Object to hold onto conversion values.
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.
Object to represent a converter class.
JPA scripting API implementation.
A JPA attribute converter class wrapped with an EclipseLink converter.
JPA scripting API implementation.
JPA scripting API implementation.
Manage field value to JDBC data type converters loaded from SPI providers.
INTERNAL:
Object to hold onto a custom converter metadata.
Java Service loader interface for data converters.
A Converters annotation allows the definition of multiple Converter.
JPA scripting API implementation.
Object to hold onto convert metadata.
Purpose: This class creates all exceptions for the copy book parser
Purpose: This class is a parser for Cobol Copy books.
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.
JPA scripting API implementation.
INTERNAL:
Incapsulates common behavior amount class for all the different types of
copy policy metadata
Key notes:
- any metadata mapped from XML to this class must be compared in the
equals method.
This class exists on on the client side which talks to remote session controller through
RMI connection.
Purpose: Define an Sun CORBA implementation class for the remote object that
can execute a remote command.
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:
AttributeGroup attribute names converter.
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.
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.
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.
INTERNAL
A abstraction of mapping capturing behavior common to all persistence types.
INTERNAL
A abstraction of project capturing behavior common to all persistence types.
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.One of the aggregate functions.
INTERNAL
Purpose: Contains the implementation of the CriteriaDelete interface of
the JPA criteria API.
Purpose: Contains the implementation of the CriteriaQuery interface of
the JPA criteria API.
Purpose: Contains the implementation of the CriteriaUpdate interface of
the JPA criteria API.
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
Purpose: Provides a wrapper around an instance of Accessor.
Used to store information about CopyPolicy as it is read from XML or
annotations
Key notes:
- any metadata mapped from XML to this class must be compared in the
equals method.
The Customizer annotation is used to specify a class that implements the
DescriptorCustomizer
interface and is to run against an entity's class descriptor after all
metadata processing has been completed.
INTERNAL:
Defines a custom ObjectInputStream that is used with SerializedObjectConverter
to ensure the correct class loader is used.
PUBLIC:
Defines a user defined partitioning policy.
INTERNAL:
This is the concrete subclass responsible for handling backward compatibility for 9.0.4.
INTERNAL:
Allows for the reflective creation of an implementation of Sun's
org.glassfish.jaxb.runtime.CycleRecoverable$Context interface.
PUBLIC:
A CacheInvalidationPolicy that allows objects to expire every day at a specific time.
INTERNAL:
DatabaseAccessor is private to EclipseLink.
INTERNAL:
Purpose: Used as an abstraction of a database invocation.
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.
INTERNAL:
Database platform JSON extension.
Purpose:
Hold the configuration information necessary to connect to a JDBC driver.
INTERNAL:
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.
DatabasePlatform is private to EclipseLink.
Purpose: Abstract class for all database query objects.
Used for parameter retreival in JPQL
Purpose:
Abstract class for all database query mechanism objects.
Purpose: Define a representation of a database row as field=>value pairs.
Purpose: Add login and configuration API to that of Session.
INTERNAL:
Implementation of org.eclipse.persistence.sessions.DatabaseSession
The public interface should be used.
INTERNAL:
PUBLIC: Interface used to categorize arguments to Stored Procedures as either
'simple' (use subclass SimpleDatabaseType) or 'complex' (use subclass ComplexDatabaseType)
This expression represents the database specific data type, which may include size and scale.
Purpose: Any exception raised by DatabaseTypeBuilder should be this exception class.
There are quite a few places where we have 'if (x instanceof YYY)'.
The query BNF for the database type.
There are quite a few places where we have 'if (x instanceof YYY)'.
A utility class to help
DDLParser keep track of DatabaseType's.INTERNAL: a helper class that holds DatabaseType's.
DatabaseValueHolder wraps a database-stored object and implements
behavior to access it.
Superclass for all expression that have a context.
A Factory for creating DataObjects.
Used to configure the data format type for an EIS descriptor.
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.
This interface defines the public interface for the EclipseLink DatabaseRecord (was Record),
and the other record types XMLRecord, EISRecord.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
DatasourceAccessor is an abstract implementation
of the Accessor interface providing common functionality to the concrete database and EIS accessors.INTERNAL:
Purpose: Used as an abstraction of a datasource invocation.
Purpose:
Mechanism used for call queries.
Simplest of all possible holder objects for all of the data source
info required by the Entity test environment.
A stubbed out impl of DataSource that can be used for testing.
Purpose:
Hold the configuration information necessary to connect to a datasource.
DatasourcePlatform is private to TopLink.
INTERNAL:
This expression represents a date represented in JDBC escape syntax, for instance, the String:
{d '1901-01-01'} can be used to represent a Date and use used only by the JPQL parser.
INTERNAL
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.
This
DateTimeStateObject represents a date or time.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.
INTERNAL: runtime implementation of EclipseLink Database Web Service (DBWS)
PUBLIC: runtime exception for EclipseLink DBWS Service
INTERNAL:
Purpose:
PUBLIC: model object for eclipselink-dbws.xml descriptor file.
This interface defines methods necessary for packaging generated artifacts for
deployment to application servers, display in Java IDEs, etc.
Token literal values and constants.
Token Manager.
The abstract definition of
JPQLQueryDeclaration.This
Resolver is responsible to visit the current query (which is either the top-level
query or a subquery) and gathers the information from the declaration clause.This defines the declaration portion of a query, which is the
FROM clause
of a query.INTERNAL:
A decorated database table is one that has an as of clause, for Oracle 9R2
query flashback.
This
IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed,
which means this formatter can only be used when the
StateObject was created by parsing a JPQL
query because it needs to retrieve parsing information from the corresponding
Expression.This utility class provides basic refactoring support.
The default implementation of a
ICaseExpressionStateObjectBuilder.The default implementation of
IConditionalExpressionStateObjectBuilder.
Purpose:Use this Connector to build a java.sql.Connection in the
"standard" fashion, via the DriverManager.
The default implementation of
ContentAssistProposals which stores the valid proposals.This visitor traverses the JPQL parsed tree and gathers the possible proposals at a given position.
This
JPQL grammar provides support for parsing JPQL queries defined by the
latest Jakarta Persistence functional specification and the latest EclipseLink.An implementation of
IJPQLQueryBuilder that provides support based on the latest release
of the Java Persistence functional specification.If there is no text node then apply the default value.
INTERNAL:
A default implementation of ErrorHandler that simply rethrows the SAXParseExceptions.
This validator is responsible to validate a JPQL query grammatically purely based on the JPA
specification document.
This
JPQL grammar provides support for parsing JPQL queries defined in the
latest Jakarta Persistence functional specification.An implementation of
IJPQLQueryBuilder that provides support based on the latest release
of the Java Persistence functional specification.This context is used to store information related to the JPQL query.
The default implementation of a
IJPQLQueryFormatter, which support creating a string
representation of a JPQL query written for JPA 1.0 and 2.0.This helper can perform the following operations over a JPQL query:
Calculates the result type of a query:
AbstractJPQLQueryHelper.getResultType();
Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String).
Calculates the possible choices to complete the query from a given
position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int).
Validates the query by introspecting it grammatically and semantically:
AbstractJPQLQueryHelper.validate(),
AbstractJPQLQueryHelper.validateGrammar(),
AbstractJPQLQueryHelper.validateSemantic().
Refactoring support:
DefaultJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the
refactoring operation through a collection of TextEdit objects.
DefaultJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through
the editable StateObject and
once all refactoring operations have been executed, the IJPQLQueryFormatter will
generate a new string representation of the JPQL query.
This helper should be used when the JPQL query is written using the JPQL grammar defined in the
Java Persistence functional specification 1.0 or 2.x.Default database platform JSON extension service provider.
This visitor traverses an
Expression
and retrieves the "literal" value.The default implementation of
INewValueStateObjectBuilder.This visitor calculates the type of an input parameter.
The default implementation of
Problem.The default implementation of
RefactoringDelta which contains the TextEdit that
were creating during the refactoring of a JPQL query.This utility class provides basic refactoring support.
The default implementation of a
ResolverBuilder, which follows the 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
This validator is responsible to gather the problems found in a JPQL query by validating the
content to make sure it is semantically valid.
Purpose: Reference to the default sequence.
INTERNAL:
Purpose: Default log used for the session when message logging is
enabled.
INTERNAL:
The default implementation of
BasicStateObjectBuilder, which provides support for
creating a StateObject
representation of any Expression.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.
The default implementation of a
TextEdit, which contains the location of the change within
the JPQL query (offset) and the old and new values.Purpose:Provide a default implementation of the UnmappedContentHandler
Purpose:Provide a default implementation of the UnmappedContentHandler
Purpose:Default implementation of the ValueStore interface.
Class called to transform Java names to XML names.
Abstract change record for collection type records that allow deferrable change detection.
PUBLIC:
A DeferredChangeDetectionPolicy defers all change detection to the UnitOfWork's
change detection process.
Purpose: ContentHandler to store events until we know if we are dealing with a simple, complex or empty element.
INTERNAL:
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.
This is the
DELETE clause of the DELETE statement.INTERNAL:
DeleteNode is a ModifyNode that represents an DeleteAllQuery
Purpose: Used for deleting objects.
INTERNAL:An XR DeleteOperation is an executable representation of a
DELETE
operation on the database.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.Bulk delete operation apply to entities of a single entity class (together with its subclasses,
if any).
Purpose: Provides Derby DBMS specific behavior.
The query BNF for a derived collection member declaration expression.
This
DerivedDeclaration represents an identification variable declaration that was
declared in the FROM clause of a SELECT subquery.A derived id class accessor is found within an entity's embedded id class
and is a reference back to a parents id class.
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.
INTERNAL:
Use to sort vectors of strings.
Deprecated, for removal: This API element is subject to removal in a future version.
This constructor will be marked private and the class final.
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: Define any useful static methods to manipulate with descriptors content.
This class provides a generic way of using the descriptor information
to traverse an object graph.
INTERNAL:
A DeferredContentHandler that will throw an exception when a descriptor
can't be found unless it's a simple element which will be processed by the mapping.
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.
A direct accessor.
An abstract direct collection accessor.
Purpose: This class holds the record of the changes made to a collection attribute of
an object.
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.
INTERNAL:
Object to hold onto relation (fk and pk) column metadata in a Eclipselink
database field.
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.
Change record used by DirectMapMapping.
Mapping for a collection of key-value pairs.
This is an implementation of
Archive when container returns a file:
url that refers to a directory that contains an exploded jar file.This is an implementation of
Archive which is used when container
returns a jar: URL.
Purpose: Define an alias to a database field.
Purpose:
Concrete class to perform a direct read.
Purpose: To record the changes for attributes that can be represented as DirectToField
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.
Helper class to abstract the XML mapping for DirectToXMLType.
INTERNAL:
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.
INTERNAL:
A discriminator class is used within a variable one to one mapping.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to process a JPA discriminator column into an EclipseLink database field.
Purpose: Super class to all remote client session's.
INTERNAL:
Subclass of IdentityMapAccessor for distributed sessions
Overrides some IdentityMapInitialization code
INTERNAL
One of the four binary operators.
TODO:
Purpose: This is for DMS related messages
English ResourceBundle for DMSLocalization messages.
Purpose: Define the interface of EclipseLink profiler for using DMS gate.
Purpose: Class to represent the documentLocator event
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:
INTERNAL:
INTERNAL:
Implementation of Attributes - used to pass along a given node's attributes
to the startElement method of the reader's content handler.
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.
INTERNAL:
INTERNAL
INTERNAL
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.This abstract class is used to represent an entity which typically is not
realized in Java code.
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.
Information about a property is extracted (thru DynamicType) from the entity's ClassDescriptor
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.
INTERNAL:
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.
An EntityType provides a metadata facade into the EclipseLink
object-relational metadata (descriptors & mappings) with specific knowledge
of the entity types being dynamic.
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
IJPQLQueryFormatter is used to generate a string representation of a StateObject based on how it was parsed,
which means this formatter can only be used when the StateObject was created by parsing a
JPQL query because it needs to retrieve parsing information from the corresponding Expression.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.EclipseLink specific
ClassVisitor that generates a corresponding ClassFile structure
for currently running Java VM.EclipseLink specific
ClassVisitor that generates a corresponding ClassFile structure
for currently running Java VM.This utility class provides basic refactoring support.
The EclipseLink extension over the basic support provided by
IConditionalExpressionStateObjectBuilder.This extension over the default content assist visitor adds the additional support EclipseLink
provides.
This visitor adds support for the additional clauses provided by EclipseLink, such as the
The EclipseLink implementation of
DeclarationResolver that adds support for its
additional support.
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
JPQLGrammar provides support for parsing JPQL queries defined
in Jakarta Persistence 3.1 and the additional support provided by EclipseLink 4.0.An implementation of
IJPQLQueryBuilder that provides support based on the release
of the Java Persistence functional specification defined in
JSR-337 - Java Persistence 2.0.This context is used to store information related to the JPQL query.
The default implementation of a
IJPQLQueryFormatter that adds support for formatting
EclipseLink specific JPQL identifiers.This helper can perform the following operations over a JPQL query:
Calculates the result type of a query:
AbstractJPQLQueryHelper.getResultType();
Calculates the type of an input parameter: AbstractJPQLQueryHelper.getParameterType(String).
Calculates the possible choices to complete the query from a given
position (used for content assist): AbstractJPQLQueryHelper.buildContentAssistProposals(int).
Validates the query by introspecting it grammatically and semantically:
AbstractJPQLQueryHelper.validate(),
AbstractJPQLQueryHelper.validateGrammar(),
AbstractJPQLQueryHelper.validateSemantic().
Refactoring support:
EclipseLinkJPQLQueryHelper.buildBasicRefactoringTool() provides support for generating the delta of the
refactoring operation through a collection of TextEdit objects.
EclipseLinkJPQLQueryHelper.buildRefactoringTool() provides support for refactoring the JPQL query through
the editable StateObject and
once all refactoring operations have been executed, the IJPQLQueryFormatter will generate
a new string representation of the JPQL query.
This helper should be used when the JPQL query is written using the JPQL grammar defined in the
Java Persistence functional specification 2.1 and it contains the additional support provided by
EclipseLink.This visitor traverses an
Expression
and retrieves the "literal" value.
Purpose: Any EclipseLink message in Foundation Library & J2EE Integration JARs
should be a subclass of this class.
English ResourceBundle for EclipseLinkLocalization messages.
INTERNAL:
INTERNAL: Define the EclipseLInk OX project and descriptor information to read an EclipseLink
project from an XML file.
This visitor calculates the type of an input parameter.
This refactoring tool add support for EclipseLink specific extension over the default
implementation of JPQL defined in the Java Persistence functional specification.
An implementation of a
ResolverBuilder that adds support for EclipseLink extension.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 extension provides additional support to semantic validation by adding support for non-JPA
specific artifacts, such as database objects.
The default implementation of
BasicStateObjectBuilder, which provides support based on
the JPQL grammar defined in the Java Persistence functional specification and for the additional
support provided by EclipseLink.The interface is used to traverse the
StateObject hierarchy that represents a JPQL
query as well as what EclipseLink adds on top of the basic grammar.An enumeration listing the various releases of EclipseLink.
PUBLIC: EclipsePackager extends
IDEPackager.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.INTERNAL:
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.
Value holder used to defer an EIS 1-m mapping query.
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.
Concrete JPA query class.
A Value Object class representing XML Schema's Element.
Purpose: This class defines the
FieldMetaData interface it defines
various behavior associated with a field and stores meta-information about the field.JPA scripting API implementation.
An element collection accessor.
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:
An embeddable accessor.
JPA scripting API implementation.
INTERNAL
Common interface to those mappings that are used to map JPA Embedded objects.
Purpose: Provides the implementation for the EmbeddableType interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
JPA scripting API implementation.
An embedded relationship accessor.
JPA scripting API implementation.
An embedded id relationship accessor.
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 tests whether or not the collection designated by the collection-valued path
expression is empty (i.e, has no elements).
INTERNAL
Converts from empty node to true or false
An
EmptyIterable is just that.A
null instance of an Iterator.
Purpose: Define a singleton empty record to avoid record creation when not required.
This
Expression represents an identification variable that maps a Map
property, either the key, the value or a Map.Entry).This object represents an identification variable that is wrapped by a function.
Custom visitor that will iterate through enclosed types, building up
a list of type instances.
Purpose: Class to represent the endCDATA event
Purpose: Class to represent the endDocument event
Purpose: Class to represent the endDTD event
Purpose: Class to represent the endElement event
Purpose: Class to represent the endEntity event
Purpose: Class to represent the endElement event
JPA scripting API implementation.
An entity accessor.
A callback listener for those entities that define callback methods.
A metadata class to facilitate the processing of lifecycle methods on an
entity class (and its mapped superclasses).
The query BNF for a entity expression.
EntityFetchGroup reflects the state of the object.
Concrete JPA EntityGraph class.
JPA scripting API implementation.
An EntityListener is placed on the owning entity's descriptor.
JPA scripting API implementation.
JPA scripting API implementation.
A MetadataEntityListener and is placed on the owning entity's descriptor.
Purpose: Provides the implementation for the EntityManager Factory.
Wraps our implementation of EntityManagerFactory
Most operations are forwarded to the delegate.
This is a helper/impl class for the EclipseLink EJB 3.0 provider
The default constructor can be used to build the provider by reflection, after which it can
be used to create EntityManagerFactories
Purpose: Contains the implementation of the EntityManager.
The class defines EclipseLink properties' names for use at the EntityManager level.
INTERNAL:
English ResourceBundle for EntityManagerSetupException messages.
INTERNAL:
This class handles deployment of a persistence unit.
The query BNF for a entity or value expression.
This
Resolver retrieves the type for an abstract schema name (entity name).Entity resource.
JPA scripting API implementation.
Purpose:
Concrete class to represent the EntityResult structure as defined by
the EJB 3.0 Persistence specification.
JPA scripting API implementation.
INTERNAL:
Object to hold onto an entity result metadata.
JDK 1.5 version of the EntityTransaction.
INTERNAL:
JDK 1.5 specific version of EntityTransactionWrapper.
The query BNF for the TYPE expression.
Purpose: Provides the implementation for the EntityType interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
EntityTypeImpl implements the IdentifiableType interface via EntityType
EntityTypeImpl implements the IdentifiableType interface via EntityType
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.This
StateObject wraps the name of an entity type.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.
JPA scripting API implementation.
INTERNAL:
Abstract converter class that parents both the JPA and Eclipselink
converters.
The query BNF for a enum expression.
The query BNF for an enumeration constant expression.
This
Resolver retrieves the type for an enum constant.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:
This
StateObject wraps the name of an Enum constant.A helper for comparing DataObjects.
INTERNAL:
EqualsAssignmentNode is implemented to distinguish nodes that hold updates in an update
query from other BinaryOperatorNodes
INTERNAL
Makes the ErrorResponse class available to JAXB context.
Exception handler can catch errors that occur on queries or during database access.
Purpose: This is for non EclipseLink exceptions
English ResourceBundle for ExceptionLocalization messages.
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.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.INTERNAL
The purpose of this class is to try explain the nature of a dead lock
INTERNAL:
A custom implementation of a linked list.
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: Represents an Expression in the Criteria API heirarchy.
Used to itterate an expression tree, through inner subclasses.
Purpose: Expression Java printer.
Purpose: This class mirrors the java.lang.Math class to allow mathimetical function support within expressions.
This is used during the normalization process to allow for a single main expression traversal.
Purpose: ADVANCED: The expression operator is used internally to define SQL operations and functions.
INTERNAL:
Used by function operators in deployment xml generation to accomodate custom functions.
Purpose:
Mechanism used for all expression read queries.
This registry contains the necessary information used by Hermes parser.
Purpose: Expression SQL printer.
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).This class is used to introduce new events to the standard ContentHandler
interface that can be leveraged by MOXy.
This class is used to introduce new methods to the standard Source
interface that can be leveraged by MOXy.
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.Expression operator customization for
EXTRACT(<date-time-part> FROM <date-time>).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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a fetch attribute metadata from a named fetch group
metadata.
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.
JPA scripting API implementation.
Purpose: The fetch group manager controls the named fetch groups defined at
the descriptor level.
INTERNAL:
Object to hold onto a named fetch group metadata.
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.
INTERNAL
JPA scripting API implementation.
Define a structured data type's field name for an object mapped to NoSql data.
Purpose: Define a database field definition for creation within a table.
Field expressions represent a field of a table.
JPA scripting API implementation.
A node that represents a field instruction.
INTERNAL:
Synonym for Column for NoSql data.
Purpose: This interface defines behavior for a field meta data be they elementary or
composite.
A node that represents a field.
INTERNAL:
Define JPA meta-data for partitioning policy.
PUBLIC:
FieldPartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's id, location, or tenant.
A
FieldVisitor that remaps types with a Remapper.JPA scripting API implementation.
Purpose:
Concrete class to represent the FieldResult structure as defined by
the EJB 3.0 Persistence specification.
JPA scripting API implementation.
INTERNAL:
Object to hold onto an field result metadata.
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.
INTERNAL:
This class is used to store the field transformations on the TransformationMapping.
PUBLIC:
This interface is used by the Transformation Mapping to build the value for a
specific field.
Purpose: Provides an empty implementation of FieldTransformer.
INTERNAL:
Purpose: Used to define aggregate mapping field translations deployment XML mappings.
INTERNAL:
Purpose: Define a database platform specific definition for a platform independent Java class type.
A visitor to visit a Java field.
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".
INTERNAL
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.
JPA scripting API implementation.
INTERNAL:
Object to process JPA foreign key metadata.
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.
Purpose:Represents The FOR UPDATE pessimistically locking clause.
Purpose:Represents The FOR UPDATE OF fine-grained pessimistically
locking clause.
This class is used when marshalling to a ContentHandler when the fragment flag on XMLMarshaller is true
It wraps a given ContentHandler and passes the events to that ContentHandler
The startDocument and endDocumentevents are not triggered on the reference ContentHandler.
A node that represents a stack map frame.
Represents an alias to a item selected by a from clause sub-select.
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.The
FROM clause of a query defines the domain of the query by declaring
identification variables.
Purpose: Contains the implementation of the From interface of the JPA
criteria API.
INTERNAL
This
Resolver wraps a subquery that is used as the "root" object in a query's declaration.This virtual
IMapping wraps one of the select items.Allow a table expression to be created on a sub-select to define a sub-select in the from clause.
Purpose: A FullIdentityMap holds all objects stored within it for the life of the application.
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.
INTERNAL
INTERNAL
Used for expressions that have 0 to n children.
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.
Purpose: Contains the implementation of the Predicate interface of the JPA
criteria API.
INTERNAL:
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.
JPA scripting API implementation.
Metadata object to hold generated value information.
INTERNAL
INTERNAL:
A
MethodVisitor with convenient methods to generate code.A generic
JPQLQueryBNF can be used to manually create a new BNF without having to create
a concrete instance.Utility class for Generic class hierarchy.
An implementation of
SemanticValidatorHelper that uses JPQLQueryContext to return
the required information and Hermes SPI.This generic implementation of
ITypeHelper wraps ITypeHelper and delegates the
calls to it.PUBLIC:
This is the concrete subclass responsible for representing Glassfish server behavior.
INTERNAL:
The generic platform configuration for the Glassfish server.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for Glassfish JTA
Purpose: TransactionController implementation for Glassfish JTA
INTERNAL
INTERNAL
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
GROUP BY construct enables the aggregation of values according to the
properties of an entity class.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.INTERNAL
Database Platform for SAP HANA
A reference to a field or a method.
Purpose: A HardCacheWeakIdentityMap is identical to the weak identity map, however the weak reference
can be a performance problem for some types of apps because it can cause too much garbage collection
of objects read causing them to be re-read and re-built (this defeats the purpose of the cache).
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.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
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.The
HAVING construct enables conditions to be specified that further restrict
the query result as restrictions upon the groups.INTERNAL
Purpose: This class contains some simple methods that are helpful and used through
the classes
INTERNAL:
INTERNAL:
This interface represents a helper execution context.
This class instantiates a HelperProviderImpl that returns concrete helpers.
This class compiles a JPQL query into a
DatabaseQuery.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.INTERNAL:
Hint values.
INTERNAL:
An impersonating database table is one that pretends to be another database
table, and whose true identity is revealed only when printed as SQL.
INTERNAL:
Purpose: Allows the reading of objects as of a past time.
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.
This builder is used by
BasicStateObjectBuilder, which allows subclasses to easily change
any internal builders used for properly creating the state model representation of a JPQL query.This builder is responsible to create a
CASE expression.This builder can be used to easily create a conditional expression without having to create each
object manually.
The external representation of a Java class constructor.
JPA scripting API implementation.
A relational accessor.
Purpose: Provides the implementation for the Entity interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
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.An identification variable is a valid identifier declared in the
FROM clause
of a query.INTERNAL
This
IdentificationVariableFactory creates a new IdentificationVariable.This
Resolver is responsible to resolve the type of an identification variable.This state object represents a single identification variable, which is identifying TODO.
A role describes the purpose of the JPQL identifier.
Purpose: Provides the interface for IdentityMap interaction.
INTERNAL:
Internal subclass that provides access to identity maps through the session.
PUBLIC:
IdentityMapAccessor provides the public interface into all functionality associated with
EclipseLink's cache.
Allows to iterate over
CacheKey instances stored in the IdentityMap.Purpose: Maintain identity maps for domain classes mapped with EclipseLink.
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.
JPA scripting API implementation.
IDResolver can be subclassed to allow customization of the ID/IDREF processing of
Unmarshaller.
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.
INTERNAL:
IdValidation configures which id values are considered valid when loading
from the database.
The EclipseLink extension over the basic support provided by
IEclipseLinkConditionalStateObjectBuilder.This enumeration lists the mapping types defined in the Java Persistence functional specification
and those that are provided by EclipseLink.
The external representation of the managed type that is annotated with
@jakarta.persistence.Embeddable.The external representation of the managed type that is annotated with
@jakarta.persistence.Entity.Purpose: Class to represent the endElement event
INTERNAL:
A node that represents an IINC instruction.
This builder is responsible to create an editable
StateObject representation of a JPQL
query.A
IJPQLQueryFormatter helps to write a string representation of a StateObject.This enumeration determines how the JPQL identifiers are formatted when written out.
This is used in conjunction with
IListChangeListener.This enumeration lists the possible modification a list can have.
A
IListChangeListener can be registered with a StateObject in order to be notified
when a list changes (items are added or removed from it or some items have been moved inside of
that list).The external representation of a managed type, which is a JPA persistent object.
The external representation of the provider of managed types, which provide access to the JPA
domain model.
The interface is used to visit a
IManagedType.The external representation of the managed type that is annotated with
@jakarta.persistence.MappedSuperclass.The external representation of a mapping, which represents a single persistence property
of a managed type.
A mapping builder is used to create the appropriate implementation of a
IMapping.This enumeration lists the mapping types defined in the Java Persistence functional specification.
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.
Purpose: A helper class for sorting index/object pairs.
Allow a set of database indexes to be define on an Entity.
Index expression may be created by QueryKeyExpression.index() method
in case the QueryKeyExpression corresponds to a CollectionMapping with
non-null listOrderField.
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.The
INDEX function returns an integer value corresponding to the position of
its argument in an ordered list.JPA scripting API implementation.
INTERNAL:
Object to hold onto database index metadata.
INTERNAL
Purpose:
Provides factory methods to create JDK specific implementation
of particular type of
IndirectCollection.Define API providers of
IndirectCollection implementations must conform to.Purpose:
Purpose
IndirectList allows a domain class to take advantage of TopLink indirection
without having to declare its instance variable as a ValueHolderInterface.
PERF: Avoids reflection usage for IndirectList.
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.
The state field path expression must have a string, numeric, or enum value.
An
InformixPlatform that fixes many EclipseLink bugs
related to Informix support.Purpose: Provides Informix specific behavior.
JPA scripting API implementation.
INTERNAL:
JPA scripting API implementation.
Object to represent inheritance metadata.
Purpose: Allows customization of an object's inheritance.
Purpose: Contains the implementation of the In interface of the JPA
criteria API.
Interface to control CDI-based injection in EntityListeners
Any references to CDI specific classes should be reserved for implementers to allow this
interface to load in an environment that does not include CDI.
Manages calls to CDI to inject into managed beans
This class will be created reflectively to avoid dependencies on CDI classes in environments
that do not support CDI
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
PRIVATE: InMemoryCompiler wraps a
JavaCompiler.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.
A node that represents an inner class.
INTERNAL
Either positional or named parameters may be used.
The query BNF for a input parameter.
Either positional or named parameters may be used.
Purpose:
Used for inserting new objects into the database.
INTERNAL:An InsertOperation is an executable representation of an
INSERT
operation on the database.A doubly linked list of
AbstractInsnNode objects.A node that represents a zero operand instruction.
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.
Purpose: A wrapper class for handling cases when the domain object has instance variable
to map to the database field.
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.
JPA scripting API implementation.
INTERNAL:
Used to store information about InstantiationCopyPolicy as it is read from
XML or annotations
Key notes:
- any metadata mapped from XML to this class must be compared in the
equals method.
Purpose: Allows customization of how an object is created/instantiated.
A
MethodVisitor providing a more detailed API to generate and transform instructions.INTERNAL
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: Used to define the interaction argument mapping.
An interface accessor.
Purpose: The abstract class for ContainerPolicy's whose container class implements
a container interface.
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.
Purpose: Represents an Expression in the Criteria API implementation heirarchy.
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 parameters of the
POWER expression.The query BNF for the parameters of the
ROUND expression.
Purpose: Represents a Selection in the Criteria API implementation hierarchy.
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.
A node that represents an instruction with a single int operand.
Purpose:Indicates an object that should not be returned from
query execution.
INTERNAL: An
Invocation holds runtime argument values that are used by an
XRServiceAdapter to invoke a named OperationA node that represents an invokedynamic instruction.
This is used in conjunction with
IPropertyChangeListener.A
IPropertyChangeListener can be registered with a StateObject in order to be notified
when the value of a property changes.The external representation of a JPQL query.
Helper type that tells us for a given cache key what threads are having some sort of relationship to the cache key (e.g
acquired the cache key as an active thread, have a deferred lock on the cache key or have incremented the counter of
readers on the lock or simply are stuck waiting for the cache key to be available.
This builder can be used to easily create a scalar expression without having to create each
object manually.
This builder can be used to easily create a select expression without having to create each
object manually.
This
IsExpressionFactory creates a new expression when the portion of the query to parse
starts with IS.This builder can be used to easily create a select expression defined for a subquery without
having to create each object manually.
Provides isolation support by allowing a client session
to have a local cache of the subset of the classes.
INTERNAL:
Internal subclass that provides access to identity maps through the session.
Partition isolated
HashMap.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.
Represents a list of links for REST collection or entity resource.
Convenient
ItemLinks object builder.Makes the ItemLinks class available in our Dynamic JAXB context.
The external representation of a Java type.
The external representation of a type declaration, which is used to give more information about
the type, i.e.
The external representation of the repository of Java types, which gives access to the
application's classes.
INTERNAL: JarArchiver implements the
DBWSPackager.Archiver interface.This is an implementation of
Archive when container returns a
file: url that refers to a jar file.This is an implementation of
Archive which is used when container
returns some form of URL from which an InputStream in jar format can be
obtained.INTERNAL:
INTERNAL:
Java class for java-attribute complex type.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
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:
INTERNAL:
Makes java.math package classes available to JPA-RS JAXB context.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
JavaPlatform abstracts the version of the JDK we are using.
INTERNAL:
JavaSECMPInitializer is used to bootstrap the deployment of EntityBeans in EJB 3.0
when deployed in a non-managed setting
It is called internally by our Provider
This class loader is provided at initialization time to allow us to temporarily load
domain classes so we can examine them for annotations.
This agent is intended to be run prior to start up on a CMP3 JavaSE application.
PUBLIC: JavasePackager extends
ProviderPackager.Java SE platforms supported by EclipseLink.
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.
Java version storage class.
AttributeAccessor used in conjunction with an XMLCompositeDirectCollectionMapping to enable
support for mapping to arrays
INTERNAL
A wrapper for the SDOClassGenerator that understands the JAXB compiler options
and translates them to the SDO equivalents.
INTERNAL:
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:
Supported values of
eclipselink.moxy.factory property.This implementation of commonj.sdo.helper.DataFactory is responsible for
ensuring that newly created DataObjects are assigned a JAXB aware value store.
Convert between instances of XMLRoot and JAXBElement
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.
Implementation of a SchemaModelOutputResolver that wraps a
jakarta.xml.bind.SchemaOutputResolver instance.
This accessor should be used when processing a class that uses method access,
and a has set method but no get method.
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.
Packages generated artifacts for deployment to JBoss AS.
PUBLIC:
This is the concrete subclass responsible for representing JBoss-specific server behavior.
INTERNAL:
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for JBoss JTA
Purpose: TransactionController implementation for JBoss JTA
EclipseLink reference implementation for password encryption.
PUBLIC: Marker interface for JDBC type metadata
PUBLIC: JDBC types
INTERNAL: a helper class that holds DatabaseType's.
PUBLIC: JDevPackager extends
IDEPackager.PUBLIC:
A StructConverter that can be used to convert the oracle.spatial.geometry.JGeometry as
it is read and written from the database.
Purpose: Define the implementation of the abstract RemoteConnection for JGroups.
Purpose: Provide a transport implementation for the Remote Command Module (RCM) that publishes
to a JGroup channel.
Provides the behavior of instantiating an EIS ConnectionSpec.
Platform for Oracle JMS JCA adapter.
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.
INTERNAL:
Purpose: Define the implementation of the abstract RemoteConnection for JMS.
Purpose: Provide a transport implementation for the Remote Command Module (RCM) that both publishes
and subscribes to a JMS topic.
INTERNAL:
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.
INTERNAL:
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.
JPA scripting API implementation.
INTERNAL:
Object to process JPA join columns EclipseLink database fields.
INTERNAL
Purpose:
A common class to be used by ObjectLevelReadQueries and ReportItems.
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.
Define a structured data type's foreign key field for an object mapped to NoSql data.
JPA scripting API implementation.
INTERNAL:
Synonym for JoinColumn for NoSql data.
Allow a set of fields to be define on a relationship.
Purpose: Contains the implementation of the Join interface of the JPA
criteria API.
A
JOIN enables the fetching of an association as a side effect of the
execution of a query.JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto join table metadata in a EclipseLink database table.
Purpose: TransactionController implementation for JOTM
Extends JPA Cache interface with additional EclipseLink API.
INTERNAL:
This class is a composite object containing the classLoader and
a flag that is true if the classLoader returned is temporary.
JIRA EJBTHREE-572 requires that we use the real classLoader in place of the getNewTempClassLoader().
JIRA EJBTHREE-572 requires that we use the real classLoader in place of the getNewTempClassLoader().
Purpose: Extension to the existing conversion manager to support the
EJB 3.0 spec.
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.
Base class for all JPA initialization classes.
This class is responsible for generating an XMLEntityMappings instance based
on a given list of meta-model database types.
PUBLIC:
EclipseLInk specific JPA query interface.
Purpose:
A JPA placeholder Query object to store JPQL strings so that processing the string is delayed
until Login.
This interface defines the entry point for implementing a JPQL query parsing
system in EclipseLink.
Config class for JPA-RS REST service.
Logger for EclipseLink JPA-RS related functionality.
Concrete implementation of
PersistenceContextFactoryProvider.An enumeration listing the various releases of the Java Persistence specification.
Purpose: Used as an abstraction of a database invocation.
INTERNAL
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
JPQLGrammar provides support for parsing JPQL queries defined in Java Persistence 2.2.This
JPQLGrammar provides support for parsing JPQL queries defined in Jakarta Persistence 3.0.This
JPQLGrammar provides support for parsing JPQL queries defined in Jakarta Persistence 3.1.INTERNAL
This defines a single Backus-Naur Form (BNF) of the JPQL grammar.
An implementation of
IJPQLQueryBuilder that provides support based on the Java Persistence
functional specification defined in JSR-220 -
Enterprise JavaBeans 3.0.An implementation of
IJPQLQueryBuilder that provides support based on the Java Persistence
functional specification defined in JSR-337 - Java
Persistence 2.0.An implementation of
IJPQLQueryBuilder that provides support based on the Java Persistence
functional specification defined in JSR-338 - Java
Persistence 2.1.This builder wraps another builder and simply delegates the calls to it.
This context is used to store information related to the JPQL query.
This visitor is responsible to retrieve the
Expression that is the beginning of a
query.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.
INTERNAL: JPQLQueryHandler sets the JPQL string in the given
DatabaseQueryThis helper can perform various operations over a JPQL query.
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.
This is the root of the
StateObject hierarchy that represents 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.
JSON converter service provider.
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.
INTERNAL:
This class processes the reserve "json" converter specified through @Convert.
Reader for JSR-353 stream (StAX) parser.
Builder for JsonParserReader
Object to be used with Unmarshaller to unmarshal
JsonParser objects
Usage:
JsonParserSource source = new JsonParserSource(jsonParser);
Object unmarshalled = jaxbUnmarshaller.unmarshal(source);Default JSON database platform.
Java service manager and service loader for
DatabaseJsonPlatform interface.Java service provider interface for database platform JSOn extension.
Instances of this class are used to maintain state about the current
level of the JSON message being marshalled.
INTERNAL:
INTERNAL:
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);
INTERNAL:
Handles Json type configuration.
Default JSON field value to JDBC data type converter.
INTERNAL:
This class processes JSON converter.
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.
INTERNAL: WebServicePackager extends
ProviderPackager.A
MethodVisitor that removes JSR instructions and inlines the
referenced subroutines.
Purpose: TransactionController extensions for JTA 1.1
Purpose: Synchronization object implementation for JTA 1.0
Purpose: TransactionController implementation for JTA 1.0
INTERNAL:
JTA transaction wrapper.
A node that represents a jump instruction.
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.This object represents an identification variable that maps the keys of a
Map.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 expression representing some keywords:
TRUE, FALSE or NULL.INTERNAL:
This class processes the reserve "kryo" converter specified through @Convert.
Uses Kryo to serialize the object.
A position in the bytecode of a method.
An
AbstractInsnNode that encapsulates a Label.A node that represents an LDC instruction.
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
LENGTH function returns the length of the string in characters as an integer.INTERNAL
INTERNAL
INTERNAL
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.The
LIKE condition is used to specify a search for a pattern.INTERNAL
A node that represents a line number declaration.
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.
Purpose: Provides the capability to insert CacheKeys into a Linked List.
INTERNAL:
A custom implementation of a linked list node for use in the ExposedNodeLinkedList.
This class is used to wrap collection of Link objects
Makes the Link class available in our Dynamic JAXB context.
Represents a link used in JPARS 2.0.
Makes the LinkV2 class available in our Dynamic JAXB context.
Purpose: Provides the implementation for the ListAttribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A proxy class that allows EclipseLink to trigger the deployment of a persistence unit
as an ListAttribute is accessed in the metamodel.
The default implementation of
IListChangeListener where the generics is the type of the
items.Purpose: A ListContainerPolicy is ContainerPolicy whose container class
implements the List interface.
INTERNAL:
A ListExpressionOperator is used with an ArgumentListFunctionExpression.
A
ListHolderStateObject is a StateObject having a list of children and this
gives access to some operation over the list.A
ListIterable simply forces the returned object to be an instance of ListIterator.
Purpose: Contains the implementation of the Join interface of the JPA
criteria API.
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.
Used for wrapping literal values.
This
LiteralExpressionFactory is responsible to return the right literal expression.INTERNAL
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.
JPA scripting API implementation.
INTERNAL:
Abstract converter class that parents both the JPA and Eclipselink
converters.
INTERNAL:
The
DATE | TIME | DATETIME argument of LOCAL local_datetime_type expression.The query BNF for type part of local date/time expression.
This
LocalDateTypeFactory creates a new LocalDateTime when the portion
of the query to parse starts with LOCAL.The
LOCAL local_datetime_type expression.The query BNF for local date/time expression.
This
LocalExpressionFactory creates a new LocalExpression when the portion
of the query to parse starts with LOCAL.A node that represents a type annotation on a local or resource variable.
A node that represents a local variable declaration.
A
MethodVisitor that renumbers local variables in their order of appearance.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.The
LOCATE function returns the position of a given string within a string,
starting the search at a specified position.INTERNAL
EclipseLink categories used for logging name space.
INTERNAL:
Print a brief summary of a TopLink LogRecord in a human readable
format.
Logger type persistence property values.
Purpose: This is for any logging related messages
English ResourceBundle for LoggingLocalization messages.
INTERNAL:
Used for logical AND and OR.
This expression represents a logical expression, which means the first and second expressions are
aggregated with either AND or OR.
This expression represents a logical expression, which means the first and second expressions are
aggregated with either the
AND or the OR operator.INTERNAL
Purpose: Define the information required to connect to an EclipseLink session.
INTERNAL:
Log levels for EclipseLink logging.
INTERNAL
A node that represents a LOOKUPSWITCH instruction.
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.The
LOWER function converts a string to lower case and it returns a string.INTERNAL
Able to process computable tasks.
INTERNAL
Purpose: Provides the implementation for the ManagedType interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
This class represents a "query key" that isn't really there
in the descriptors.
JPA scripting API implementation.
INTERNAL:
A many to many relationship accessor.
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.
INTERNAL:
A many to one relationship accessor.
JPA scripting API implementation.
Purpose: Define the relationship to be a ManyToOne.
This abstract class is used to support JAXBContext creation with an array or Collection class.
Purpose: Provides the implementation for the MapAttribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A proxy class that allows EclipseLink to trigger the deployment of a persistence unit
as an MapAttribute is accessed in the metamodel.
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.
Purpose: A MapContainerPolicy is ContainerPolicy whose container class
implements the Map interface.
INTERNAL:
This inner class is used to iterate through the Map.Entry s of a Map.
INTERNAL
Purpose: Contains the implementation of the Join interface of the JPA
criteria API.
JPA scripting API implementation.
The MapKeyConvert annotation specifies that a named converter should be used
with the corresponding mapped attribute key column.
JPA scripting API implementation.
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.
Object to hold onto map key metadata.
INTERNAL
Implementation of NamespacePrefixMapper.
Defines the specification for a call to a JCA interaction using Mapped records.
Interface class to define the common map mapping metadata.
A MappedKeyMapContainerPolicy should be used for mappings to implementers of Map.
JPA scripting API implementation.
INTERNAL:
A mapped superclass accessor.
JPA scripting API implementation.
Purpose: Provides the implementation for the MappedSuperclassType interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
INTERNAL:
An abstract mapping accessor.
INTERNAL:
Use to Sort The mappings in ClassDescriptor, Mappings are either DirectToField, which must be at the top
or other
Avoid using this class as sun.misc is not part of many VM's like Netscapes.
A node value corresponding to mapping.
JPA scripting API implementation.
INTERNAL:
JPA scripting API implementation.
This abstract class is used to support JAXBContext creation with a Map class.
AttributeAccessor used in conjunction with an XMLCompositeDirectCollectionMapping
or XMLCompositeCollectionMapping to enable support for mapping to Maps in JAXB
Purpose: Provides MariaDB specific behavior.
INTERNAL:
The MarshalContext allows mappings to be marshalled differently depending on
the type of object.
An implementation of Marshaller.Listener can be set on an Marshaller
to provide additional behaviour during marshal operations.
These are properties that may be set on an instance of Marshaller.
This class represents marshal record behaviour that is specific to the SAX
platform.
A MarshalRecord encapsulates the marshal target.
A Stack-like List, used to detect object cycles during marshal operations.
INTERNAL:
Math double argument functions expressions.
The
POWER function takes two numeric arguments and returns a double.The
ROUND function takes numeric argument and an integer argument and returns
a number of the same type as the first argument.Math functions expressions factories.
The
CEILING math function expression resolver.The
FLOOR math function expression resolver.The
ROUND math function expression resolver.Math single argument functions expressions.
The
CEILING function takes a numeric argument and return a number (integer,
float, or double) of the same type as the argument.The
EXP function takes a numeric argument and returns a double.The
FLOOR function takes a numeric argument and returns a number (integer,
float, or double) of the same type as the argument.The
LN function takes a numeric argument and returns a double.The
SIGN function takes a numeric argument and returns an integer.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.One of the aggregate functions.
INTERNAL
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.
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: Provide a dynamic interface into the EclipseLink Session.
This interface represents the different media types supported by EclipseLink MOXy.
This enum represents the different media types supported by EclipseLink MOXy.
Memoizer for computing resource expensive tasks asynchronously & concurrently.
Purpose: Provide a remote command implementation for remote cache
merges of changes.
Purpose:
Used to manage the merge of two objects in a unit of work.
INTERNAL:
Parent object that is used to hold onto a valid JPA decorated method
field, class or file.
INTERNAL:
Common metadata accessor level for mappings and classes.
INTERNAL:
Parent object that is used to hold onto a valid JPA decorated method, field
or class.
Metadata representation of an annotation.
INTERNAL: A metadata factory that uses ASM technology and no reflection
whatsoever to process the metadata model.
JPARS 2.0 metadata catalog.
INTERNAL:
An object to hold onto a valid JPA decorated class.
INTERNAL:
Object to process JPA column type into EclipseLink database fields.
INTERNAL:
Common metadata processing constants.
INTERNAL:
Abstract converter class that parents both the JPA and Eclipselink
converters.
INTERNAL:
Common metatata descriptor for the annotation and xml processors.
Custom
DynamicClassWriter adding getter methods for virtual
attributes so that 3rd party frameworks such as jakarta.validation can access
the attribute values.INTERNAL:
A metadata factory is used to extract class information.
INTERNAL:
An object to hold onto a valid JPA decorated field.
INTERNAL:
Parent object that is used to hold onto a valid JPA decorated file.
Purpose: Define any useful static methods to manipulate with descriptors content.
INTERNAL:
Common helper methods for the metadata processing.
JPA scripting API implementation.
INTERNAL:
Logger class for the metadata processors.
INTERNAL:
An object to hold onto a valid JPA decorated method.
INTERNAL:
The object/relational metadata processor for the EJB3.0 specification.
INTERNAL:
A MetadataProject stores metadata and also helps to facilitate the metadata
processing.
Purpose: A Command implementation used to signal JPA EntityManagerFactory to refresh its
metadata.
JPARS 2.0 metadata catalog.
JPA scripting API implementation.
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: Provides the implementation for the Metamodel interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A named method descriptor.
Purpose: A wrapper class for handling cases when the domain object attributes are
to be accessed thru the accessor methods.
INTERNAL:
This is an implementation of FieldTransformation which stores a method name and
uses that name to instantiate a MethodBasedFieldTransformer.
Purpose:
Purpose:
Used to allow complex inheritance support.
INTERNAL:
A node that represents a method instruction.
A node that represents a method.
A
MethodVisitor that remaps types with a Remapper.INTERNAL:
Class used to represent java.lang.reflect.Method instances to allow serialization
Exception thrown when the Code attribute of a method produced by a
ClassWriter is too
large.A visitor to visit a Java method.
Processes all the methods of a class to weave in persistence code such as,
lazy value holder, change tracking and fetch groups.
Purpose:
Purpose:
One of the aggregate functions.
This
MinFunctionFactory creates a new MinFunction when the portion of the query
to parse starts with MIN.One of the aggregate functions.
INTERNAL
INTERNAL
INTERNAL:
Event listener class used to lazy-load the descriptors for EIS and XDB,
as they have external jar dependencies that may not be on the classpath.
INTERNAL:
Object to hold onto XML converter metadata.
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.The modulo operation finds the remainder of division of one number by another.
PUBLIC:
Query used to perform a bulk delete using the expression framework.
INTERNAL:
ModifyNode is the superclass for UpdateNode and DeleteNode
Purpose:
Abstract class for all modify queries.
A node that represents an exported package with its name and the module that can access to it.
A ModuleHashes attribute.
A node that represents a module declaration.
A node that represents an opened package with its name and the module that can access it.
A node that represents a service and its implementation provided by the current module.
A
ModuleVisitor that remaps types with a Remapper.A node that represents a required module with its name and access of a module descriptor.
A ModuleResolution attribute.
A ModuleTarget attribute.
A visitor to visit a Java module.
Provides connection information to the Mongo 2 database.
Provides connection information to the Mongo 3 database.
Defines the meta-data for the Mongo adapter
Provides java.sql.Timestamp, java.sql.Date and java.sql.Time codecs.
Connection to Mongo
This connection wraps a Mongo DB.
Connection factory for Mongo JCA adapter.
Defines the meta-data for the Mongo adaptor
Provides connection information to the Mongo database.
Connection to Mongo
This connection wraps a Mongo DB.
Connection factory for Mongo JCA adapter.
Defines the meta-data for the Mongo adaptor
Interaction to Mongo JCA adapter.
Interaction to Mongo JCA adapter.
Interaction spec for Mongo JCA adapter.
Defines connection information for connecting to Mongo.
Simple list result.
Defines the valid MongoDB operations.
Platform for Mongo database.
Simple mapped record.
Record factory for Mongo JCA adapter.
Transaction to Mongo adapter.
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.
A node that represents a MULTIANEWARRAY instruction.
Purpose:
Provide a version of Instantiation Policy that can make use of a multiple argument factory method.
One of the four binary operators.
TODO:
INTERNAL
Multitenant specifies that a given entity is shared amongst multiple tenants
of a given application.
JPA scripting API implementation.
A multitenant id accessor.
JPA scripting API implementation.
Object to hold onto multi-tenant metadata.
A multitenant interface.
Purpose: A wrapper class for handling cases when the domain object
has a property to map to the database field.
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.
Object to hold onto named attribute node metadata.
Object to hold onto named entity graph metadata.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto named native query metadata.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a named PLSQL stored function query.
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.
INTERNAL:
Object to hold onto a named PLSQL stored procedure query.
JPA scripting API implementation.
INTERNAL: NamedQueryHandler retrieves the TopLink
DatabaseQuery
from the named queryJPA scripting API implementation.
INTERNAL:
Object to hold onto a named query metadata.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a named stored function query.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a named stored procedure query.
Object to hold onto named sub graph metadata.
INTERNAL:
This class represents a Namespace.
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.
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.
INTERNAL:
It is common for an XML document to include one or more namespaces.
It is common for an XML document to include one or more namespaces.
Purpose: Define a database's native sequencing mechanism.
INTERNAL:
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: Interface to represent a Choice or Sequence
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.INTERNAL:
The query BNF for a new value expression.
INTERNAL:
INTERNAL
INTERNAL
Trim specification constants.
INTERNAL
INTERNAL:
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.
INTERNAL:
INTERNAL:
PUBLIC:
A cache invalidation policy in which no objects will expire.
Purpose: Provide the capability to not cache objects at all.
Purpose
The NonCacheable annotation is used to configure caching behavior for
relationships.
INTERNAL:
INTERNAL:
Properties subclass that removes the synchronization.
SubList that implements Vector.
Vector subclass that removes the synchronization.
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.
An NoSQL (No SQL, or Not Only SQL) database is any non-relational data source.
This can include:
NoSQL databases such as Oracle NoSQL, MongoDB, etc.
This can include:
NoSQL databases such as Oracle NoSQL, MongoDB, etc.
JPA scripting API implementation.
Defines the metadata for the @EIS annotation for mapping an EISDescriptor.
INTERNAL
BNF:
expression ::= NOT conditional_primaryThis
NotExpressionFactory creates a new NotExpression when the portion of the
query to parse starts with NOT.INTERNAL
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.
INTERNAL:
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 comparison tests whether or not the single-valued path expression or input parameter is a
NULL value.INTERNAL
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.NULLIF returns the first expression if the two expressions are not equal.INTERNAL
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:
A "null" implementation of a
Resolver.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.
Exact numeric literals support the use of Java integer literal syntax as well as SQL exact
numeric literal syntax.
This
Comparator is used to sort ITypes based on the numerical priority.INTERNAL:
A single object relationship accessor.
Purpose:
In an object-relational data model, structures can contain "Arrays" or collections of other data-types.
Purpose: Object builder is one of the behavior class attached to descriptor.
Purpose:
Abstract class for all read queries that build objects and potentially manipulate
the TopLink cache.
Purpose: Define a listener for object change tracking.
INTERNAL:
Implementers of ObjectChangePolicy implement the code which computes changes sets
for the UnitOfWork commit process.
Purpose: Hold the Records of change for a particular instance of an object.
Purpose: Provides API to the Class that holds all changes made to a particular Object.
Allow change sets to be compared by changes for batching.
PUBLIC:
A ObjectChangeTrackingPolicy allows an object to calculate for itself whether
it should has changed by implementing ChangeTracker.
Stores object description.
Superclass for any object type expressions.
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.Stand-alone identification variables in the
SELECT clause may optionally be
qualified by the OBJECT operator.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.
An implementation of MarshalContext for handling plain old java objects that
are mapped to XML.
INTERNAL: Define the TopLink OX project and descriptor information to read a OracleAS TopLink 10g (10.0.3) project from an XML file.
INTERNAL:
Define the TopLink OX project and descriptor information to read an AS 11g
(11.1.1) project from an XML file.
INTERNAL:
Wrap the isset parameter object array as a Collection.
INTERNAL:
Wrap the isset parameterType class array as a Collection
INTERNAL:
If the policy is the default NullPolicy with defaults set - then represent this default policy by null.
Inner class used to map Map containers where the key is String and
the value is a DatabaseType.
INTERNAL:
Amend the EclipseLink project and descriptor information to write out an EclipseLink project
to an XML file, replacing actual .class references with String equivalents
Purpose: To record the changes for an attribute that references a single Object
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto an object type converter metadata.
An ObjectTypeConverters annotation allows the definition of multiple
ObjectTypeConverter.
An implementation of UnmarshalContext for handling plain old java objects that
are mapped to XML.
Purpose: Allow for creation of object varray type.
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.
INTERNAL:
A OneToMany relationship accessor.
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.
A one to one relationship accessor.
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.
The JVM opcodes, access flags and array type codes.
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.
JPA scripting API implementation.
Object to hold onto optimistic locking metadata.
Advanced:
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.
Oracle 21c JSON database platform.
Purpose:
Supports certain new Oracle 21c data types, and usage of certain Oracle JDBC specific APIs.
Purpose:
Supports certain new Oracle 23c data types, and usage of certain Oracle JDBC specific APIs.
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.
Class used to define Oracle specific JDBC types.
JPA scripting API implementation.
An OracleArray annotation is used to define an Oracle database VARRAY type.
JPA scripting API implementation.
An OracleArrays annotation allows the definition of multiple VARRAY types.
INTERNAL:
Object to hold onto Oracle array type meta-data.
INTERNAL: a helper class that holds DatabaseType's.
PUBLIC:
Listener for Oracle Database Change event Notification (DCN).
INTERNAL:
Object to hold onto Oracle complex type meta-data.
Helper class to abstract the XML mapping for DirectToXMLType.
PUBLIC:
This class allows connection to open proxy session.
Oracle database platform JSON extension service provider.
Defines the meta-data for the Oracle NoSQL adapter
Defines the meta-data for the Oracle NoSQL SDK adapter
Connection to Oracle NoSQL
This connection wraps a KVStore.
Connection to Oracle NoSQL
This connection wraps a NoSQLHandle.
Connection factory for Oracle NoSQL JCA adapter.
Connection factory for Oracle NoSQL SDK JCA adapter.
Defines the meta-data for the Oracle NoSQL adaptor
Defines the meta-data for the Oracle NoSQL adaptor
Provides connection information to the Oracle NoSQL database.
Provides connection information to the Oracle NoSQL database.
Interaction to Oracle NoSQL JCA adapter.
Interaction to Oracle NoSQL JCA adapter.
Interaction spec for Oracle NoSQL JCA adapter.
Interaction spec for Oracle NoSQL JCA adapter.
Defines connection information for connecting to Oracle NoSQL.
Defines connection information for connecting to Oracle NoSQL.
Cloud authorization mechanisms.
NoSQL service type.
Defines the valid Oracle NoSQL operations.
Defines the valid Oracle NoSQL operations.
Deprecated.
This class is no longer supported according to changes in Oracle NoSQL Database access.
Platform for Oracle NoSQL database.
Simple mapped record.
Simple mapped record.
Record factory for Oracle NoSQL JCA adapter.
Record factory for Oracle NoSQL JCA adapter.
Transaction to Oracle NoSQL JCA adapter.
Transaction to Oracle NoSQL JCA adapter.
JPA scripting API implementation.
An OracleObject annotation is used to define an Oracle database OBJECT type.
JPA scripting API implementation.
An OracleObjects annotation allows the definition of multiple Oracle OBJECT
types.
INTERNAL:
Object to hold onto Oracle object type meta-data.
INTERNAL: a helper class that holds DatabaseType's.
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.The
ORDER BY clause allows the objects or values that are returned by the
query to be ordered.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.INTERNAL
An
ORDER BY 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.Object to hold onto order by metadata.
INTERNAL
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to process a JPA order column into an EclipseLink database field.
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.
INTERNAL:
This is used to keep information on a single collection change for attribute change tracking on ordered lists.
Purpose: A OrderedListContainerPolicy is ContainerPolicy whose
container class implements the List interface and is ordered by an @OrderBy.
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.The
OR logical operator chains multiple criteria together.INTERNAL:
A custom AttriuteAccessor to be used when the same object is mapped in both
OXM and ORM.
INTERNAL:
Abstract/common level for JPA Object/Relational metadata.
INTERNAL
Holder class storing a QueryKeyExpression representing an outer join
plus some data calculated by method appendFromClauseForOuterJoin.
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:
Object to hold onto common attribute/association override metadata.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
System properties holder.
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.
INTERNAL:Name and type (
QName) for a bound argument.Parameter delimiter char hint values.
Used for parameterized expressions, such as expression defined in mapping queries.
INTERNAL:
INTERNAL
A node that represents a parameter of a method.
This visitor calculates the type of an input parameter.
This exception is thrown when parse errors are encountered.
Parser type property values.
Parser type property values.
INTERNAL
INTERNAL
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.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
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.
Purpose: Contains the implementation of the Path interface of the JPA
criteria API.
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.
Define an interface for utility methods weaved into the persistence classes.
Purpose: This is the default copy policy when weaving is used.
INTERNAL:
Manages the PersistenceContexts that are used by a JPA-RS deployment.
Any class that calls the initialize method on the JavaSECMPInitializer should implement this interface
Implementers of this interface can restrict the provider that the initializer will initialize with.
Define an interface for utility methods weaved into the persistence classes.
Used with weaving to access attributes without using reflection.
Used with weaving to create "empty" instances without using reflection.
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).
JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Utility Class that deals with persistence archives for EJB 3.0
Provides functions like searching for persistence archives, processing
persistence.xml and searching for Entities in a Persistence archive
Passed to processORMetadata method to indicate processing mode.
The class defines EclipseLink persistence unit property names.
Metadata catalog resource in JPARS version less than 2.0.
INTERNAL:
Marker interface used to identify classes modified by the EclipseLink weaver.
INTERNAL:
Marker interface used to identify classes modified by the TopLink weaver for change tracking.
INTERNAL:
Marker interface used to identify classes modified by the TopLink weaver for fetch groups.
INTERNAL:
Marker interface used to identify classes modified by the TopLink weaver for LAZY (ValueHolder indirection) mappings.
Used by JPA-RS to build links for relationships.
INTERNAL:
This class performs dynamic byte code weaving: for each attribute
mapped with One To One mapping with Basic Indirection it substitutes the
original attribute's type for ValueHolderInterface.
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.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
PUBLIC:
PinnedPartitionPolicy pins requests to a single connection pool.
Platform is private to TopLink.
Marks
DatabasePlatform specific wrapper of instance from ResultSet.
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)
INTERNAL: a helper class that holds DatabaseType's.
INTERNAL:
Object to hold onto a PLSQL complex type meta-data.
PUBLIC: describe an Oracle PL/SQL Cursor type
INTERNAL: a helper class that holds DatabaseTypes.
JPA scripting API implementation.
A PLSQLParameter annotation is used within a
NamedPLSQLStoredProcedureQuery or PLSQLRecord annotation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a PLSQL parameter meta-data.
JPA scripting API implementation.
PUBLIC: describe an Oracle PL/SQL Record type
A PLSQLRecord annotation is used to define a database PLSQL RECORD type.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a PLSQL record meta-data.
A PLSQLRecords annotation allows the definition of multiple
PLSQLRecord.
INTERNAL: a helper class that holds DatabaseType's.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a PLSQL table meta-data.
A PLSQLRecords annotation allows the definition of multiple
PLSQLTable.
Purpose: Provides the implementation for the PluralAttribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A proxy class that allows EclipseLink to trigger the deployment of a persistence unit
as an PluralAttribute is accessed in the metamodel.
INTERNAL
Support the Pointbase database.
INTERNAL:
Purpose: This class is used to populate example data into the database, it allows for circular references to be resolved.
PostgreSQL 10 JSON database platform.
Postgres 10 database platform extension.
Add extended JSON functionality dependent on PostgreSQL JDBC driver.
PostgreSQL database platform JSON extension service provider.
Purpose: Provides Postgres specific behavior.
Purpose: Contains the implementation of the Predicate interface of the JPA
criteria API.
INTERNAL:
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.
INTERNAL:
Object to process JPA primary key foreign key metadata.
JPA scripting API implementation.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to process JPA primary key join columns EclipseLink database fields.
Object to hold onto primary key metadata.
A PrivateOwned annotation is used to specify a relationship is privately
owned.
INTERNAL:
Privileged Access Helper provides a utility so all calls that require privileged access can use the same code.
INTERNAL
Specific
Exception supplier for PrivilegedAccessHelper.PrivilegedExceptionCallable.INTERNAL
Specific
Throwable supplier for PrivilegedAccessHelper.PrivilegedExceptionCallable.INTERNAL
A task that returns a result and shall not throw an exception.
INTERNAL
A task that returns a result and may throw an exception.
INTERNAL
A task that does not return any result and may throw an exception.
INTERNAL:
Retrieve current
Thread context ClassLoader with privileges enabled.INTERNAL:
Retrieve
System property with privileges enabled.A problem describes an issue found in a JPQL query because it is either grammatically or
semantically incorrect.
INTERNAL:
INTERNAL:
Purpose: Class to represent the endElement event
Processor for computable tasks.
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.
INTERNAL:
Purpose: Allow for a class storing a TopLink project's descriptors (meta-data) to be generated.
INTERNAL:
INTERNAL: Static helper methods that reads EclipseLink project deployment
XML without classes.
INTERNAL:
Annotation for user defined properties.
The class processes some of EclipseLink properties.
Deprecated, for removal: This API element is subject to removal in a future version.
This constructor will be marked private and the class final.
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.
Entity resource property.
INTERNAL:
JPA scripting API implementation.
Purpose: Generic association object.
The default implementation of
IPropertyChangeEvent where the generics is the type of the
old and new values.INTERNAL:
JPA scripting API implementation.
INTERNAL:
PropertyMetadata.
Purpose: provides a value holder type that can be used in Protected instances of Entities.
INTERNAL: ProviderHelper bridges between
DBWSAdapter's and JAX-WS Provider's
INTERNAL: ProviderPackager extends
XRPackager.ProxyIndirectionHandler
ProxyIndirectionPolicy
INTERNAL:
The query BNF for a qualified identification variable expression.
Purpose: Used to define the query argument mapping.
QueryBasedValueHolder wraps a database-stored object and implements behavior
to access it.
Purpose:
Mechanism used for all queries by example.
Purpose:
This policy defines the configuration options for a Query By Example query.
INTERNAL:
This counter is used by the sessions to assign individual id's to all queries.
Purpose: This exception is used for any problem that is detected with a query.
INTERNAL: English ResourceBundle for QueryException messages.
INTERNAL:
QueryHandler sets out the basic rules for how Operations can
use different types of queries (DataRead, ValueRead, etc.)JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto query hints metadata.
The class defines EclipseLink query hints.
The class processes query hints.
Configure the cache usage of the query.
Configure the cache usage of the query.
Define a generic Hint.
INTERNAL:
325167: Make reserved # bind parameter char generic to enable native SQL pass through
Define the query cache expiry hint.
Define the query cache expiry time of day hint.
Define the query cache hint.
Define the query cache ignore null hint.
Define the query cache ignore null hint.
Define the query cache randomized expiry hint.
Define the query cache size hint.
Define the query cache type hint.
Configure the type of the query.
This hint can be used to indicate whether or not a ResultSetMapping query should
return populated DatabaseRecords vs.
Concrete JPA query class.
Purpose: Define a Java appropriate alias to a database field or function.
Represents expression on query keys or mappings.
Purpose: Used to define variable 1-1 mapping query key field references.
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.
INTERNAL:
This node contains the information about what kind of query is represented it's tree
(e.g.
INTERNAL:An XR QueryOperation is an executable representation of a
SELECT
operation on the database.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.
JPA scripting API implementation.
Object to hold onto Default Redirector metadata.
Query resource.
PUBLIC:
A QueryResultsCache policy dictates how a query's results will be cached.
Purpose: An generic query sequence mechanism.
INTERNAL:
Purpose: Used to define query string calls.
Defines the specification for a call to a JCA interaction that uses a query string.
Query type hint values.
This
RangeDeclaration represents an identification variable declaration that was
declared in the FROM clause of a SELECT top-level query
or subquery.INTERNAL
Represent a specific range partition.
PUBLIC:
Represent a specific range partition.
JPA scripting API implementation.
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.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
PUBLIC:
RangePartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's id, location, or tenant.
INTERNAL:
Define JPA meta-data for partitioning policy.
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.Range variable declarations allow the developer to designate a "root" for objects which may not
be reachable by navigation.
Purpose: An abstract class that can be subclassed when internal
commands need to be added.
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.
INTERNAL:
Metadata about ReadLock acquisition
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.
JPA scripting API implementation.
INTERNAL:
Metadata for ReadTransformer.
A node that represents a record component.
A
RecordComponentVisitor that remaps types with a Remapper.A visitor to visit a record component.
The
RecordConverter interface allows conversion of an adapter
specific record.Purpose: This class contains meta information for a record.
A refactoring delta contains an ordered collection of
TextEdit.The abstract implementation providing refactoring support for JPQL queries.
This visitor renames a fully qualified class name.
This visitor renames an entity name.
This visitor renames an enum constant.
This visitor renames any segment of a path expression.
This visitor renames all the result variables found in the JPQL query.
This interface is used to transparently push the new value into the
StateObject.This visitor renames all the identification variables found in the JPQL query.
Reference to REST resource.
INTERNAL:
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.
This class is leveraged by reference mappings.
INTERNAL:
Extended
DynamicClassLoader used to create classes using reflective
access to defineClass.INTERNAL:
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.INTERNAL:
Object to process JPA relational type colummns into EclipseLink database fields.
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.
INTERNAL:
Object to hold onto a relational table metadata in an EclipseLink
database table.
Purpose:Used for all relation operators except for between.
INTERNAL:
A relational accessor.
Stores information about a relationships mapping that is used by JPA-RS to build links for relationships.
Purpose: Contains relation table functionality
that was originally defined in ManyToManyMapping
and now is shared with OneToOneMapping.
INTERNAL:
A class responsible for remapping types and names.
Purpose: This Interfaces provides the reference part of an remote command framework
Whereby, TopLink can issue commands to distributed servers.
Purpose: Provide a CommandManager implementation for cache coordination.
INTERNAL:
Instances of this exception are raised if a problem is detected in the
RemoteCommandManager (RCM) feature.
INTERNAL:
English ResourceBundle for RemoteCommandManagerExceptionResource messages.
Purpose: Define an abstract class for the remote object that can execute
a remote command using different transport protocols.
Defines set of abstract methods which one must overwrite for any kind to implement a communication mechanism.
Purpose:
The object is used as a wrapper to the CursoredStream object in the remote transaction (via RMI, CORBA, etc.)
Purpose: This Interface provides the reference part of an remote command framework
Whereby, TopLink can issue function calls to distributed servers.
Remote JPA protocol persistence property values.
Purpose:
The object is used as a wrapper to the ScrollableCursor object in the remote transaction (via RMI, CORBA, etc.)
Purpose: Provide transparent remote three-tiered replacation support.
RemoteSessionController sits between the remote session (on the client)
and whatever session is running on the server.
Counter part of the unit of work which exists on the client side.
Remote value holders can be invoked locally and remotely.
Purpose: This class provides an implementation of a RemoteSessionCommand
Helper class for RemoteSessionController.
ReplicationPartitioning sends requests to a set of connection pools.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
PUBLIC:
ReplicationPartitioningPolicy sends requests to a set of connection pools.
Purpose: represents an item requested (i.e.
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.
A
Resolver is responsible to resolve a property by retrieving either the managed
type, the mapping, the type and the type declaration depending on the type of resolver.This visitor creates a
Resolver that gives information about the visited Expression.This visitor is used to check if the expression visited is a
CollectionExpression.REST resource.
This class describes an entity schema.
Collections adapter used in JPARS V2.
This class is used to generate XML type adapters for collection references in JPARS 2.0.
INTERNAL: RestClassWriter uses ASM to dynamically generate subclasses of
DynamicEntity with REST specific methods.Collection fields annotated by this annotation support pagination in JPARS service.
This annotation annotation allows the definition of multiple
RestPageableQuery.
Defines a pageable query.
This class is used to generate XML type adapters for single entity references in JPARS 2.0.
INTERNAL: Sub-component of an
Operation, indicates the type
of return value from the database, as well as if there is more than one value
and if those value(s) will be handled using binary attachements.This is used to retrieve the new JPQL query when a content assist item needs to be insert at
a certain position.
JDBC ResultSet concurrency hint values.
Purpose:
Concrete class to perform read using raw SQL and the SQLResultSetMapping.
PERF: Record used by ObjectLevelReadQuery ResultSet optimization.
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.A result variable may be used to name a select item in the query result.
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.
JPA scripting API implementation.
Object to hold onto return insert metadata.
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.
Purpose: Provide an RMI-IIOP transport implementation for RCM.
INTERNAL:
INTERNAL:
Purpose: The interface for the remote RMI object used for transporting
the remote command.
Purpose: The implementation for the remote RMI-IIOP object used for
transporting the remote command.
Purpose: The implementation for the remote RMI object used for
transporting the remote command.
Purpose: Define an RMI implementation class for the remote object that
can execute a remote command.
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.
INTERNAL:
Root is used to hold an Object along with the corresponding QName and some other related information.
Purpose: Contains the implementation of the Root interface of the JPA
criteria API.
RoundRobinPartitioning sends requests in a round robin fashion to the set of connection pools.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
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.
Purpose: Abstract class to represent an event from a ContentHandler or LexicalHandler
INTERNAL:
INTERNAL:
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.
INTERNAL:
INTERNAL:
Interface for controlling where schema files are generated.
Purpose: TopLink OX project to map org.eclipse.persistence.internal.schema.model.*
Used by TopLink SDO and JAXB implementations
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.SDO Property
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
SDO Type
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.
Wrapper for Boolean Object datatype.
Wrapper for Boolean datatype.
Wrapper for Byte Object datatype.
Wrapper for HEX Binary datatype.
Wrapper for Bytes datatype.
Wrapper for Byte datatype.
Wrapper for Character Object datatype.
Wrapper for Character datatype.
Wrapper for Date Time datatype.
Wrapper for Date datatype.
Wrapper for Day datatype.
Wrapper for Decimal datatype.
Wrapper for Double Object datatype.
Wrapper for Double datatype.
Wrapper for Duration datatype.
Wrapper for Float Object datatype.
Wrapper for FLoat datatype.
Wrapper for Integer datatype.
Wrapper for Int Object datatype.
Wrapper for Int datatype.
Wrapper for Long Object datatype.
Wrapper for Long datatype.
Wrapper for Month Day datatype.
Wrapper for Month datatype.
Wrapper for Object datatype.
Wrapper for Short object datatype.
Wrapper for Short datatype.
Wrapper for Strings datatype.
Wrapper for String datatype.
Wrapper for Time datatype.
Wrapper for URI QName datatype.
Wrapper for URI datatype.
Wrapper for YearMonthDay datatype.
Wrapper for YearMonth datatype.
Wrapper for Year datatype.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a secondary table metadata in a TopLink database table.
TopLink encryption interface
EclipseLink encryption interface
Holder of a SecurableObject.
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.The
SELECT statement queries data from entities, which determines the type of
the objects or values to be selected.
Purpose: An implementation of the OptimisticLockingPolicy interface.
The query BNF for a select expression.
INTERNAL:
An extension of GenerationContext the provides SELECT specific behavior.
Purpose: Contains the implementation of the Selection interface of the JPA
criteria API.
INTERNAL:
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.This state object represents a select statement, which has at least a
SELECT
clause and a FROM clause.FeatureResponseBuilder implementation generating 'self' and 'canonical' links.
This helper is used by
AbstractSemanticValidator in order to retrieve JPA information.Internal implementation of the PersistenceUnitInfo detailed in the EJB 3.0 specification
Used by our Java SE implementation so common method calls can be used in setting
of Container and non-Container EntityManagerFactories.
INTERNAL:
Object to hold onto persistence unit properties as specified in the
persistence.xml property.
A sequence is a heterogeneous list of
properties and corresponding values.Purpose: Class to represent a Sequence in a Schema
Purpose: Abstract class to define sequencing.
INTERNAL:
Purpose: Allow a generic way of creating sequences on the different platforms,
and allow optional parameters to be specified.
An implementation of MarshalContext for handling sequenced objects that
are mapped to XML.
In order to mark a domain object as being a Sequenced Object it must
implement this interface.
JPA scripting API implementation.
JPA scripting API implementation.
A wrapper class to the MetadataSequenceGenerator that holds onto a
@SequenceGenerator for its metadata values.
Purpose: Sequence definition Native Sequence object.
Purpose: Define interface to use sequencing.
Purpose: Define interface for sequencing callback.
Purpose: Define interface for sequencing callback factory.
INTERNAL:
Purpose: Define an interface to control sequencing functionality.
SequencingFactory is private to EclipseLink.
Purpose: This class declares sequencing remote function calls classes
Purpose: Define interface for getting all sequencing interfaces.
Purpose: Define interface for sequencing server.
INTERNAL:
Interface to hold onto a DescriptorEvents within a project so they can be rebuilt after serialization.
Provide common functionalities for serialization of object.
A SerializedConverter is used to serialize an object's value into a database binary, character, or XML field.
INTERNAL:
Abstract metadata serializer.
A TypeConverters annotation allows the definition of multiple SerializedConverter.
INTERNAL:
This class processes the reserve "serialized" converter specified through @Convert.
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.
Object to hold onto serialized object policy metadata.
It's a transition class that holds SerializedObjectPolicy class name
and field obtained from matadata before it can be instantiated.
Generic serializer interface.
A
ClassVisitor that adds a serial version unique identifier to a class if missing.
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.
INTERNAL:
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
INTERNAL:
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.
INTERNAL:
Purpose: A structured message object to announce a new RCM service
instance becoming available
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.
INTERNAL:
INTERNAL:
Subclass of IdentityMapAccessor for Session brokers
Overrides some identiy map initialization code
INTERNAL:
INTERNAL:
INTERNAL:
Deprecated, for removal: This API element is subject to removal in a future version.
This constructor will be marked private and the class final.
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.
Allows actions to be performed upon receipt of various Session events.
Purpose: Used to support session events.
Purpose: Used to support session events.
INTERNAL:
Helper class to simplify the development and generation of code that accesses
TopLink through the SessionManager (sessions config XML).
This is a finalizer for a session.
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.
INTERNAL:
Builds EclipseLink Sessions from the XML Session Config model.
Generic tuning interface.
Purpose: Provides the implementation for the SetAttribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
A proxy class that allows EclipseLink to trigger the deployment of a persistence unit
as an SetAttribute is accessed in the metamodel.
Purpose: Contains the implementation of the Join interface of the JPA
criteria API.
INTERNAL:
This node holds a list of all the updates that will occur in an Update Query.
Setting objects are used to control the order in which the
mappings for Sequenced Objects are processed.
A parser for signature literals, as defined in the Java Virtual Machine Specification (JVMS), to
visit them with a SignatureVisitor.
A
SignatureVisitor that remaps types with a Remapper.A visitor to visit a generic signature.
A SignatureVisitor that generates signature literals, as defined in the Java Virtual Machine
Specification (JVMS).
INTERNAL:
The query BNF for a simple arithmetic expression.
The query BNF for a simple case expression.
The query BNF for a simple conditional expression.
INTERNAL
PUBLIC: Marker interface for Simple Database types
(e.g.
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.
The
FROM clause of a sub-query defines the domain of the sub-query by
declaring identification variables.
Purpose: RemoteFunctionCall's interface implementors that
don't use remoteSessionController parameter in execute method
may extend this class
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.
INTERNAL: a helper class that holds DatabaseType's.
PERF: Record used by ObjectLevelReadQuery ResultSet optimization.
The query BNF for a result variable expression.
The SELECT statement queries data from entities.
The query BNF for the simple select clause.
The SELECT statement queries data from entities.
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.This state object represents a subquery, which has at least a
SELECT clause
and a FROM clause.This
StateObject simply holds onto a string.A
SingleElementListIterable returns a ListIterator
that holds a single element
and returns it with the first call to ListIterator.next(), at
which point it will return false to any subsequent
call to ListIterator.hasNext().A
SingleElementListIterator holds a single element and returns it with the first
call to SingleElementListIterator.next(), at which point it will return false to any subsequent call
to SingleElementListIterator.hasNext().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.
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.
Purpose: Provides the implementation for the SingularAttribute interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
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.The
SIZE function returns an integer value, the number of elements of the
collection.INTERNAL
Purpose: Class to represent the skippedEntity event
EclipseLink logger bridge over SLF4J.
A
SnapshotCloneIterable returns an iterator on a "snapshot" of a
collection, allowing for concurrent access to the original collection.provide access to "internal" constructor
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
INTERNAL: implementation of EclipseLink
XMLAttachmentMarshaller implementation
handles binary attachmentsINTERNAL: Helper class holds the value returned for a DBWS Operation
Parent class for all DBWS Operations' code-generated Response sub-classes; the contained
result field is mapped as appropriate for each code-generated Response sub-class
in
SOAPResponseWriterINTERNAL: A subclass of
ClassLoader that exposes a build method to the hidden
private ClassLoader.defineClass(byte[], int, int) method.Purpose: Container class for storing objects in an IdentityMap.
Purpose: A SoftCacheWeakIdentityMap is identical to the WeakIdentityMap, however the weak reference
can be a performance problem for some types of apps because it can cause too much garbage collection
of objects read causing them to be re-read and re-built (this defeats the purpose of the cache).
Purpose: A SoftIdentityMap holds all objects referenced by the application.
INTERNAL
Purpose: A SortedCollectionContainerPolicy is ContainerPolicy whose
container class implements the SortedInterface interface.
This class is used to construct expressions that use Oracle Spatial operators
INTERNAL:
This class produces a number of ExpressionOperators for spatial classes
The static methods in this class are used by Oracle9Platform to initialize
these 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: Print DELETE statement with non trivial WHERE clause
Purpose: Print DELETE statement.
Purpose: Print INSERT statement.
Purpose: Mirror SQL behavior.
INTERNAL: JPQLQueryHandler sets the JPQL string in the given
DatabaseQueryPurpose:
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto an sql result mapping metadata.
Purpose: Print SELECT statement.
Purpose: Provides SQL Server specific behavior.
Purpose: Mirror SQL behavior.
Purpose: Print UPDATE statement.
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.The
SQRT function takes a numeric argument and returns a Double.INTERNAL
This is a complete UnmarshalNamespaceResolver implementation.
Purpose: An abstract class providing default sequence behavior.
Default tuner.
Purpose: Class to represent the startCDATA event
Purpose: Class to represent the startDocument event
Purpose: Class to represent the startDTD event
Purpose: Class to represent the startElement event
Purpose: Class to represent the startEntity event
Purpose: Class to represent the startPrefixMapping event
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.A single-valued association field is designated by the name of an association-field in a
one-to-one or many-to-one relationship.
This
Resolver is responsible to resolve the type of a state field, which is the leaf of
the state field path expression.Purpose:
Mechanism used for all statement objects.
A
StateObject is an editable representation of a JPQL query.The visitor is used to traverse the
StateObject hierarchy that represents a JPQL query.A
ClassVisitor that merges <clinit> methods into a single one.
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.
The class provides a set of methods to pack passed-in entries into the sepcified archive file.
A helper class used by EntityManagerSetupImpl class for static weaving.
The class provides a set of methods to pack passing in entries into the sepcified archive file.
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.
INTERNAL: StoredFunctionQueryHandler sets up the StoredFunctionCall
and its arguments in the given
DatabaseQueryPurpose: 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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a stored procedure parameter metadata.
INTERNAL: StoredProcedureQueryHandler sets up the StoredProcedureCall
and its arguments in the given
DatabaseQueryConcrete JPA query class.
INTERNAL:
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.
INTERNAL
NOTE CURRENTLY BEING USED
INTERNAL:
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.INTERNAL
A string literal is enclosed in single quotes.
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.
JPA scripting API implementation.
INTERNAL:
Place holder for a StructConverter
This class will allow a StructConverter to be added to a Session through
annotations when defined with the StructConverter annotation.
A StructConverters annotation allows the definition of multiple
StructConverter.
This class contains predefined StructConverter types.
JPA scripting API implementation.
Defines the metadata for the @Struct annotation for mapping
ObjectRelationshipDataTypeDescriptor.
Struct types are extended object-relational data-types supported by some databases.
JPA scripting API implementation.
Defines a StructureMapping metadata.
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 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.
This
Declaration uses a subquery as the "root" object.This
Resolver retrieves the type for an abstract schema name (entity name) if it can
be resolved otherwise a derived path will be assumed.The query BNF for the from clause defined in a subquery.
Purpose: Contains the implementation of the SubQuery interface of the JPA
criteria API.
INTERNAL
INTERNAL:
Allow a table to reference a sub-select to support sub-selects in the from clause.
This is used to support subselects.
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.The second and third arguments of the
SUBSTRING function denote the starting
position and length of the substring to be returned.INTERNAL
One of the four binary operators.
TODO:
One of the aggregate functions.
This
SumFunctionFactory creates a new SumFunction when the portion of the query
to parse starts with SUM.This
Resolver is responsible to calculate the type based on the type of the state field.One of the aggregate functions.
INTERNAL
INTERNAL:
org/eclipse/persistence/internal/remotecommand/corba/sun/SunCORBAConnection.java .
org/eclipse/persistence/internal/remotecommand/corba/sun/SunCORBAConnectionHelper.java .
org/eclipse/persistence/internal/remotecommand/corba/sun/SunCORBAConnectionHolder.java .
Purpose: The implementation is for the remote Sun CORBA object that is used for
transporting the remote command.
org/eclipse/persistence/internal/remotecommand/corba/sun/SunCORBAConnectionOperations.java .
INTERNAL:
Purpose: Provides Sybase ASE specific behavior.
Symfoware Server
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.
INTERNAL:
Represents the aliased tables an ObjectExpression will be translated to,
along with any of its derived TableExpressions.
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.
This
Declaration uses a database table as the "root" object.
Purpose: Allow a generic way of creating tables on the different platforms.
A TableExpression allows for a raw database table to be referenced in a query.
Defines a table expression.
The query BNF for a table expression.
This
TableExpressionFactory creates a new TableExpression.JPA scripting API implementation.
JPA scripting API implementation.
A wrapper class to a table generator metadata.
JPA scripting API implementation.
INTERNAL:
Object to hold onto table metadata in a TopLink database table.
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.
INTERNAL:
Purpose: Allow a generic way of creating sequences on the different platforms,
and allow optional parameters to be specified.
A code generator for switch statements.
A node that represents a TABLESWITCH instruction.
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.
JPA scripting API implementation.
INTERNAL
INTERNAL:
Abstract converter class that parents both the JPA and Eclipselink
converters.
Tenant discriminator column(s) are used with a SINGLE_TABLE multitenant
strategy.
JPA scripting API implementation.
JPA scripting API implementation.
Object to hold onto tenant discriminator metadata.
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.
JPA scripting API implementation.
Object to hold onto tenant table discriminator metadata.
An enum that is used within the TenantTableDiscriminator annotation.
A
TextEdit contains the information of a change that can be made to the JPQL query
after performing a refactoring operation.Special List/Vector subclass that allows concurrent
population of the contents while the list is in use.
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.
JPA scripting API implementation.
Object to hold onto time of day metadata.
Used as a helper class for TIMESTAMP, TIMESTAMPTZ and TIMESTAMPLTZ in oracle9.
Purpose: Used to allow a single version timestamp to be used for optimistic locking.
This class is used as a wrapper for TIMESTAMPLTZ.
Oracle TIMESTAMP types are defined here to make sure deployment xml has no dependency
on jdbc jar.
This class is used as a wrapper for TIMESTAMPTZ.
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.
Describes the input token stream.
Token Manager Error.
Purpose: This is for any toString messages
English ResourceBundle for ToStringLocalization messages.
Purpose: This is for any trace related messages
Messages are not currently translated by default here.
English ResourceBundle for TraceLocalization messages.
INTERNAL:
English ResourceBundle for TransactionException messages.
Deprecated.
Deprecated.
INTERNAL:
Wraps a class that returns a JDK 1.5 EntityTransaction.
Transformation is an optional annotation for org.eclipse.persistence.mappings.TransformationMapping.
JPA scripting API implementation.
INTERNAL:
TransformationAccessor.
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 record the changes for attributes that can be represented as Transformation Mapping
Purpose: To Provide API to the TransformationMappingChangeRecord.
INTERNAL:
An implementation of FieldTransformation which holds onto a transformer class-name
which will be instantiated to do transformations
This class creates a ClassFileTransformer that is used for dynamic bytecode
weaving.
Transformer helper class.
This class is building properties from write transformers.
Provides return type from write transformation method.
JPA scripting API implementation.
INTERNAL:
An transient accessor ...
PUBLIC:
This class is used by our JPA annotation processing to discover which annotations may coexist with a
jakarta.persistence.Transient annotation.
JPA scripting API implementation.
Purpose
As the name signifies the object is responsible for carrying read objects from the server to the client.
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.
INTERNAL:
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.Returns an expression that allows to treat its base as if it were a subclass of the class
returned by the base.
This
Resolver resolves a path and casts it as another entity type.INTERNAL:
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.The
TRIM function trims the specified character from a string.INTERNAL
A node that represents a try catch block.
A
MethodVisitor adapter to sort the exception handlers.Tuning persistence property values.
Purpose: This is a special subclass of the ReportQuery that constructs Tuple results.
A representation of the type of a
property of a data object.A Java field or method type.
A node that represents a type annotation.
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.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a type converter metadata.
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.
Purpose: Base class for Sequence, Choice and All
Purpose: Class to represent an object that can be the owner of sequence, choice, all in a Schema
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.An entity type expression can be used to restrict query polymorphism.
Look up a Type given the uri and typeName or interfaceClass.
INTERNAL
This helper contains methods related to
IType and can perform equivalency checks.INTERNAL
Purpose: Provides the implementation for the Type interface
of the JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
INTERNAL:
A node that represents a type instruction.
Purpose: Used to define object-type converter object->data values mapping.
Purpose: Provides a wrapper for a java type to be used when creating a JAXB context.
The path to a type argument, wildcard bound, array element type, or static inner type within an
enclosing type.
A reference to a type appearing in a class, field or method declaration, or on an instruction.
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.
INTERNAL
Purpose: Defines sequencing through using a singleton sequence table.
INTERNAL:
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.Subclass of Field for fields that are mapped to unions.
UnionPartitioning sends queries to all connection pools and unions the results.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
PUBLIC:
UnionPartitionPolicy sends queries to all connection pools and unions the results.
JPA scripting API implementation.
JPA scripting API implementation.
INTERNAL:
Object to hold onto a unique constraint metadata.
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: This is the overall collection of changes.
Purpose: To Provide API to the UnitOfWorkChangeSet.
Unit of work specific identity map which avoid additional overhead not required in unit of work,
such as locking and synchronization.
INTERNAL:
IdentityMapAccessor subclass for UnitOfWork
Overrides some initialization functionality and some behavior having to do with
getting objects from identity maps.
Implementation of org.eclipse.persistence.sessions.UnitOfWork
The public interface should be used.
UnitOfWorkQueryValueHolder wraps a database-stored object and
implements behavior to access it.
UnitOfWorkTransformerValueHolder wraps a database-stored object and
implements behavior to access it.
A UnitOfWorkValueHolder is put in a clone object.
INTERNAL:
Purpose: Represents a query level AS OF TIMESTAMP/SCN Oracle SQL clause.
This
Declaration represents an unknown (invalid/incomplete) declaration.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.This
StateObject holds onto an unknown portion of a JPQL query that could not be parsed.Purpose:Provide an interface that can be implemented for handling
unmapped content during unmarshal operations with SAXPlatform.
Purpose:Provide an interface that can be implemented for handling
unmapped content during unmarshal operations with SAXPlatform.
INTERNAL:
This class delegates all events corresponding to the UnmappedContentHandler.
INTERNAL:
The UnmarshalContext allows mappings to be unmarshalled differently depending
on the type of object.
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.
An implementation of UnmarshalListener can be set on an Unmarshaller to
provide additional behaviour during unmarshal operations.
Class used to unmarshal SAX events to objects.
These are properties that may be set on an instance of Unmarshaller.
An UnmarshalNamespaceResolver that delegates all work to a NamespaceContext.
An abstraction to represent a namespace resolver for unmarshalling based on
the XML input.
This class represents unmarshal record behaviour that is specific to the SAX
platform.
Purpose:Provide an implementation of ContentHandler that is used by TopLink OXM to
build mapped Java Objects from SAX events.
INTERNAL:
Exception thrown in
AnnotationNode.check(int), ClassNode.check(int), FieldNode.check(int) and MethodNode.check(int) when these nodes (or their children, recursively)
contain elements that were introduced in more recent versions of the ASM API than version passed
to these methods.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.This is the
UPDATE clause of the UPDATE statement.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.The
new_value specified for an update operation must be compatible in type with the
field to which it is assigned.INTERNAL:
UpdateNode is a ModifyNode that represents an UpdateAllQuery
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
UPDATE clause of a query consists of a conditional expression used to
select objects or values that satisfy the expression.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.The
UPPER function converts a string to upper case and it returns a string.INTERNAL
This is an implementation of
Archive when container returns a url
that is not one of the familiar URL types like file or jar URLs.INTERNAL:
INTERNAL: provides useful constants, SQL Column <-> to XML name mapping and
a few other misc.
Utility class typically used when constructing JPA/JAXB metadata from a
list of meta-model database types.
Default UUID field value to JDBC data type converter.
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.
JPA scripting API implementation.
A wrapper class to the @UuidGenerator for its metadata values.
A UuidGenerators annotation allows the definition of multiple UuidGenerator.
INTERNAL:
Abstract converter class that parents both the JPA and Eclipselink
converters.
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.This object represents an identification variable that maps the values of a
Map.
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.
INTERNAL: simple helper object to hold scalar query results
(xsd:int, xsd:decimal, etc)
Represent a specific value partition.
JPA scripting API implementation.
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.
JPA scripting API implementation.
INTERNAL:
Define JPA meta-data for partitioning policy.
PUBLIC:
ValuePartitioningPolicy partitions access to a database cluster by a field value from the object,
such as the object's location, or tenant.
INTERNAL:
Define JPA meta-data for partitioning policy.
Purpose:
Concrete class to perform a read of a single data value.
ValueAccessor is a specialized AttributeAccessor enabling access to property values
Purpose
The ValueStore interface exposes the property model in SDO to pluggable implementers
that wish to wrap their object model in the SDO API.
This defines a variable declaration, which has a "root" object and an identification variable.
INTERNAL
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.
INTERNAL:
A variable one to one relationship accessor.
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.
A node that represents a local variable instruction.
Purpose: Allow for creation of varray type.
PERF: Avoids reflection usage for Vectors.
This class provides "empty" and "unmodifiable" wrappers for the Vector class.
JPA scripting API implementation.
This class stores variables for the version and build numbers that are used
in printouts and exceptions.
INTERNAL:
A basic version accessor.
JPA scripting API implementation.
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.
Data-holding object that holds information about object used by mappings with
a VIRTUAL access type.
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.
Purpose: Container class for storing objects in an IdentityMap.
Purpose: A WeakIdentityMap holds all objects referenced by the application only.
INTENRAL:
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.
A WeavedObjectBasicIndirectionPolicy is used by OneToOne mappings that are LAZY through weaving
and which use Property(method) access.
PUBLIC:
This is the concrete subclass responsible for representing WebLogic 10 specific behavior.
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
PUBLIC:
This is the concrete subclass responsible for representing WebLogic9 specific behavior.
INTERNAL:
PUBLIC: WeblogicPackager extends
JSR109WebServicePackager.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
INTERNAL:
INTERNAL:
INTERNAL:
INTERNAL:
PUBLIC:
This is the concrete subclass responsible for representing WebSphere
6.1-specific server behavior.
INTERNAL:
INTERNAL:
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.A
WHEN predicate is used to calculate a condition and when it's true, its
THEN will be executed.INTERNAL
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.The
WHERE clause of a query consists of a conditional expression used to
select objects or values that satisfy the expression.INTERNAL
PUBLIC:
This is the concrete subclass responsible for representing WildFly-specific server behavior.
INTERNAL:
Purpose: Provide a dynamic interface into the EclipseLink Session.
Purpose: TransactionController implementation for WildFly JTA
Purpose: TransactionController implementation for WildFly JTA
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.
INTERNAL:
Purpose: The wrapper policy can be used to wrap all objects read from the database in another object.
WrappingValueHolder is an interface type that implementors use when they will be
wrapping another ValueHolder that has the original value.
INTERNAL:
INTERNAL:
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.
JPA scripting API implementation.
INTERNAL:
Matadata for WriteTransformer.
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.
INTERNAL:
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.
INTERNAL:
Any collection XML mappings map an attribute that contains a heterogenous collection of
objects to multiple XML elements.
INTERNAL:
Java class for anonymous complex type.
Any object XML mappings map an attribute that contains a single object to an XML element.
INTERNAL:
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.
Object to represent all the attributes of an XML defined entity,
mapped-superclass or embeddable.
INTERNAL:
Purpose:Provide a mapping for a collection of binary data values that can be treated
as either inline binary values or as an attachment.
INTERNAL:
INTERNAL
Purpose:Provide a mapping for binary data that can be treated as either inline or as
an attachment.
INTERNAL:
PUBLIC:
INTERNAL:
INTERNAL:
Creates JAXB context.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
Java class for anonymous complex type.
This class is responsible for generating one or more EclipseLink XmlBindings
objects based on a given list of XMLDescriptors.
This class is responsible for holding a list of XmlBindings.
Wrap the value inside a CDATA section.
PUBLIC:
INTERNAL:
INTERNAL:
PUBLIC:
INTERNAL:
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.
INTERNAL:
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.
INTERNAL:
Composite direct collection XML mappings map a collection of simple types (String, Number, Date,
etc.) to and from a sequence of composite XML nodes.
INTERNAL:
Composite object XML mappings represent a relationship between two classes.
INTERNAL:
XMLConstants maintains a list of useful XML constants.
This interface represents behaviour that is common to all XML mappings that
involve containers: Collection, Map, Arrays, etc.
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:
INTERNAL:
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.descriptors.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.
INTERNAL:
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.
Object to hold onto the XML entity mappings metadata.
This class is responsible for generating an XMLEntityMappings instance based
on a given OR Project's Queries and Descriptors.
INTERNAL:
EclipseLink ORM mapping file OX mapping project.
ORM.xml reader.
ORM.xml reader.
INTERNAL:
Java class for anonymous complex type.
Java class for anonymous complex type.
This converter handles references when dealing with text or markup in an XML document.
This class is used to expose an XMLEventReader as an InputSource.
Convert and XMLEventReader into SAX events.
TopLink XML mappings make use of XMLFields based on XPath statements to find the relevant
data in an XML document.
Defines the meta-data for the XML file adapter
Connection to XML file JCA adapter.
Connection factory for XML file JCA adapter.
Defines the meta-data for the XML file adaptor
Provides the behavior of instantiating a XML file adapter ConnectionSpec.
Provides the behavior of instantiating a XML file adapter ConnectionSpec.
Interaction to XML file JCA adapter.
Interaction spec for XML file JCA adapter.
Platform for XML file emulated JCA adapter.
Record factory for XML file JCA adapter.
Provides sequence support for EISPlatform
INTERNAL:
Transaction to XML file JCA adapter.
Purpose: This mapping provides a means to keep a part of the xml tree as a collection
of DOM elements.
INTERNAL:
Purpose: This mapping provides a means to keep a part of the xml tree as a DOM element.
INTERNAL:
Internal:
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.
Converter that wraps an XmlAdapter.
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.
INTERNAL:
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.
INTERNAL:
This class processes the reserve "xml" converter specified through @Convert.
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
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.
INTERNAL:
TopLink OXM version of a 1-1 mapping.
INTERNAL:
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.
Object to hold onto the XML persistence unit defaults.
INTERNAL:
Object to hold onto the XML persistence unit metadata.
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.
INTERNAL:
Validate the SAX events reported to the ContentHandler.
A common super class for all non SAX based XMLReaders.
Convert a ContentHandler to an ExtendedContentHandler
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.
Nil: This is used to indicate that this field represents xsi:nil="true"
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.
Purpose:An extnesion of XMLDescriptor that's used for sequened
objects.
INTERNAL:
Uses JAXB (MOXy runtime) to convert an object to XML.
Provide a mechanism for loading Session configuration XML files.
INTERNAL:
This class was generated by the TopLink project class generator.
INTERNAL:
OX mapping project for the 11gR1 sessions XML schema.
INTERNAL:
OX mapping project provides back compatibility for toplink
10g and 11g sessions XML meta-data reading.
INTERNAL:
This class is used by the Mapping Workbench Session Configuration to write the session config
to XML.
INTERNAL:
This class is used to expose an XMLStreamReader as an InputSource.
Convert an XMLStreamReader into SAX events.
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.
INTERNAL:
Used the create an XMLType for XDB support.
INTERNAL:
Used the create an XMLType for XDB support.
This is a dummy class which is used as a stand in for
oracle.xdb.XMLType in class comparisions to prevent exceptions.
Subclass of XMLField for fields that are mapped to unions.
Class used to unmarshal XML & JSON to objects.
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.
INTERNAL
Utility class for finding XML nodes using XPath expressions.
INTERNAL:
Purpose: Perform operations based on SDO XPath against DataObjects.
INTERNAL:
This singleton provides support for querying DataObjects
via xpath expression where the result is a List containing
one or more simple types or DataObjects.
INTERNAL:
This class represents the pairing of a local name and a namespace uri.
Defines the specification for a call to a JCA interaction that uses XQuery.
INTERNAL: XRClassWriter uses ASM to dynamically generate subclasses of
XRDynamicEntity
INTERNAL: XRDynamicClassLoader uses ASM to dynamically
generate subclasses of
XRDynamicEntity
INTERNAL: XRDynamicEntity is used for models where Java classes do not
exist.
INTERNAL: XRDynamicEntityAccessor is used by dynamically generated
subclasses of
XRDynamicEntity to 'close over' information for the
psuedo-attributes in the propertiesMap inherited from XRDynamicEntity.
INTERNAL: XRDynamicEntityVHAccessor is similar to
XRDynamicEntityAccessor; however, it is used exclusively by O-X mappings
as they require attribute navigation through the ValueHolder to the
contained value.Local cache of property names
Dummy implementation of
DynamicType
PUBLIC: XRPackager implements the
DBWSPackager interface.INTERNAL: runtime implementation of TopLink XR Service
INTERNAL: helper class that knows how to build a
XRServiceAdapter (a.k.a DBWS).INTERNAL:
Implementation of MetadataSource to allow passing JPA metadata to the
MetadataProcessor.
INTERNAL:
Implementation of MetadataSource to allow passing XmlBindings
to the DynamicJAXBContextFactory
INTERNAL:
PersistenceUnitInfo implementation to allow creation of a MetadataProcessor
instance.
INTERNAL: internal DBWS model object allows conformity across APIs
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:
org/eclipse/persistence/internal/remotecommand/corba/sun/_SunCORBAConnectionImplBase.java .
org/eclipse/persistence/internal/remotecommand/corba/sun/_SunCORBAConnectionStub.java .