All Classes

This AbsExpressionFactory creates a new AbsExpression when the portion of the query to parse starts with ABS.

This Resolver is responsible to calculate the IType based on the type of the ABS expression.

This abstract implementation of ICaseExpressionStateObjectBuilder adds support for creating a CASE expression.

Define an embedded collection of objects.

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.

This builder wraps another builder and delegates the calls to it.

Purpose: Allows customization of how an object is cloned.

This Expression takes care of parsing an expression that encapsulates two expressions separated by a comma.

The abstract implementation of EclipseLinkExpressionVisitor.

This visitor retrieves the clause owning the visited Expression.

The abstract definition of EclipseLinkStateObjectVisitor, which implements all the methods but does nothing.

This StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given StateObject.

This StateObjectVisitor traverses up the hierarchy.

This expression handles parsing the identifier followed by an expression encapsulated within parenthesis.

The abstract definition of ExpressionVisitor, which implements all the methods but does nothing.

The FROM clause of a query defines the domain of the query by declaring identification variables.

The base validator responsible to gather the problems found in a JPQL query by validating it against the provided JPQL grammar.

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.

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.

This factory is responsible to return the right literal expression.

The abstract definition of a modify statement.

PUBLIC: Description: This node null policy allows for the handling of various representations of null in XML documents.

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).

The abstract definition of a range declaration, which is used to navigate to a "root" object.

The abstract definition of a refactoring

This abstract definition of a builder provides the support for creating expressions defined by a scalar expression.

The query BNF for an abstract schema name.

An abstract schema name designates the abstract schema type over which the query ranges.

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.

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.

Represents the abstract log that implements all the generic logging functions.

This expression handles parsing a JPQL identifier followed by an expression encapsulated within parenthesis.

Base class for all single result query resources.

The abstract definition of a builder of a StateObject hierarchy based on a JPQL fragment that is manually created.

Purpose: Abstract Synchronization Listener class Description: This abstract class is paired with the AbstractTransactionController class.

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 StateObjectVisitor traverses the entire hierarchy of the JPQL parsed tree by going down into each of the children of any given StateObject.

This StateObjectVisitor traverses up the hierarchy.

This state object takes care of parsing an expression that encapsulates three expressions separated by a comma.

This visitor is responsible to traverse the children of a CollectionExpression in order to properly validate the Expression.

This visitor gathers the children of a CollectionExpression or a single visited Expression.

This visitor retrieves the clause owning the visited Expression.

Purpose: Provides Microsoft Access specific behavior.

JPA scripting API implementation.

TODO: BNF: arithmetic_expression ::= arithmetic_expression + arithmetic_term

Purpose: Define the Public interface for the Aggregate Collection Change Record.

The query BNF for an aggregate expression.

In the SELECT clause the result of a query may be the result of an aggregate function applied to a path expression.

Purpose:Two objects can be considered to be related by aggregation if there is a strict 1:1 relationship between the objects.

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.

This AllOrAnyExpressionFactory creates a new AllOrAnyExpression when the portion of the query to parse starts with ALL, ANY or SOME.

The AND logical operator chains multiple criteria together.

The AND logical operator chains multiple criteria together.

Purpose:Provide a class which is responsible for returning Annotations from AnnotatedElements.

INTERNAL:

This visitor allows a subclass to simply override AnonymousStateObjectVisitor.visit(StateObject) and perform the same task for all visited ItateObjects.

INTERNAL: This class using WLS classed to get unique application ID.

Provides an abstraction to deal with various kinds of URLs that can be returned by PersistenceUnitInfo.getPersistenceUnitRootUrl()

This expression represents an arithmetic expression, which means the first and second expressions are aggregated with an arithmetic sign.

This ExpressionFactory creates a new expression when the portion of the query to parse starts with an arithmetic identifier.

This expression simply adds a plus or minus sign to the arithmetic primary expression.

This state object simply adds a plus or minus sign to the arithmetic primary expression.

The query BNF for an arithmetic term expression.

JPA scripting API implementation.

Helper class to consolidate all the heinous comparing and merging code for the Array collection mappings.

An ArrayIterator provides a Iterator for an array of objects.

Purpose:Wraps an immutable value for a past time.

The query BNF for the AS OF clause.

Purpose:Wraps an immutable value for a past time, represented as a database system change number.

The exception thrown when the condition is not met.

JPA scripting API implementation.

INTERNAL:

PUBLIC: An AttributeChangeTrackingPolicy allows change tracking at the attribute level of an object by implementing ChangeTracker.

JPA scripting API implementation.

Purpose: Provides an empty implementation of AttributeTransformer.

One of the aggregate functions.

One of the aggregate functions.

The query BNF used for an expression that is invalid.

This wraps an invalid portion of the JPQL query that could not be parsed.

An abstract implementation of a IJPQLQueryFormatter.

The abstract implementation providing refactoring support for JPQL queries.

A BatchFetch annotation can be used on any relationship mapping, (OneToOne, ManyToOne, OneToMany, ManyToMany, ElementCollection, BasicCollection, BasicMap).

BatchFetchPolicy defines batch reading configuration.

Specify the use of batch writing to optimize transactions with multiple writes, by default batch writing is not used.

BeanValidationException should be used to represent any exception that happens during Bean Validation in MOXy.

INTERNAL: Asynchronously starts validation.xml file processing when created.

XJC Plugin for generation of JSR349 (Bean Validation) annotations.

The query BNF for the between expression.

Used in conditional expression to determine whether the result of an expression falls within an inclusive range of values.

The query BNF for a boolean expression.

The query BNF for a boolean primary expression.

The Cache annotation is used to configure the EclipseLink object cache.

Cache coordination protocol persistence property values.

Allow a cache index to be define.

JPA scripting API implementation.

A CacheInterceptor can be set on an Entity and allows all EclipseLink cache access to be intercepted by the developer provided interceptor.

Purpose: Define a class through which Cache access can be intercepted.

Options for how Entity instances should be shared within an EclipseLink Persistence Unit / ServerSession

Configures what type of Id value is used to store the object in the cache.

The CacheType enum is used with the Cache annotation for a persistent class.

Cache usage hint values.

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.

Define the foreign key defined by the relationship to cascade the delete on the database.

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 END

This CaseExpressionFactory creates a new CaseExpression when the portion of the query to parse starts with CASE.

The query BNF for the case operand specified in the case expression.

The query BNF for the CAST function.

Purpose: An implementation of the OptimisticLockingPolicy interface.

Purpose: Define the base Change Record API.

Purpose: Define an interface for any object that wishes to use attribute change tracking.

JPA scripting API implementation.

Provide an interface to allow for custom character escaping behaviour.

Purpose: Abstract descriptor class for defining persistence information on a class.

Purpose: Abstract class to allow complex inheritance support.

This Resolver simply holds onto the fully qualified class name of the IType.

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.

A CloneCopyPolicy is used to set an org.eclipse.persistence.descriptors.copying.CloneCopyPolicy on an Entity.

JPA scripting API implementation.

A CloneIterator iterates over a copy of a collection, allowing for concurrent access to the original collection.

A CloneListIterator iterates over a copy of a list, allowing for concurrent access to the original list.

Description: Place holder for CMP specific information.

The query BNF for a coalesce expression.

A COALESCE expression returns null if all its arguments evaluate to null, and the value of the first non-null argument otherwise.

Purpose: Define a change event for collection types.

Purpose: Define an interface for any collection that wishes to use attribute change track.

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.

This StateObject is a temporary object used to store a list of StateObjects.

An identification variable declared by a collection member declaration ranges over values of a collection obtained by navigation using a path expression.

This CollectionMemberDeclarationFactory creates a new CollectionMemberDeclaration when the portion of the query to parse starts with IN.

This expression tests whether the designated value is a member of the collection specified by the collection-valued path expression.

This CollectionMemberExpressionFactory creates a new CollectionMemberExpression when the portion of the query to parse starts with MEMBER, MEMBER OF, NOT MEMBER or NOT MEMBER OF.

JPARS 2.0 collection proxy interface.

JPA scripting API implementation.

This Resolver is responsible to resolve the type of a collection-valued 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.

Makes the CollectionWrapper class available in our Dynamic JAXB context.

JPA scripting API implementation.

Purpose: Provide an extendable framework class for a Command object that can be remotely executed.

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.

Commit order type persistence property values.

INTERNAL: English ResourceBundle for CommunicationException messages.

The query BNF for a comparison expression.

Only the values of like types are permitted to be compared.

Purpose: Used to return multiple sets of information from a query.

A compound expression 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.

This ConcatExpressionFactory creates a new ConcatExpression when the portion of the query to parse starts with CONCAT.

Factory class to create concrete subclasses of abstract classes.

INTERNAL: English ResourceBundle for ConcurrencyException messages.

The query BNF for a conditional factor expression.

The query BNF for a conditional term expression.

The query BNF for a CONNECT BY clause.

Purpose: Used to specify how a client session's should be allocated.

Purpose: Used to specify how connection should be pooled in a server session.

Purpose: Allows a field to always be mapped to a constant value.

In the SELECT clause a constructor may be used in the SELECT list to return one or more Java instances.

This ConstructorExpressionFactory creates a new ConstructorExpression when the portion of the query to parse starts with NEW.

The query BNF for a constructor item expression.

JPA scripting API implementation.

Interface used by clients to interact with the assorted mappings that use ContainerPolicy.

This object stores the various proposals available for content assist for a certain position within a JPQL query.

Holds onto the IType of the enum type and the list of possible enum constants.

Purpose: Conversion exceptions such as method or class not defined will raise this exception.

A ConversionValue annotation is used within an ObjectTypeConverter.

The Convert annotation specifies that a named converter should be used with the corresponding mapped attribute.

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.

Purpose: Conversion interface to allow conversion between object and data types.

A JPA attribute converter class wrapped with an EclipseLink converter.

Purpose: Define how an object is to be copied.

Purpose: Allows customization of how an object is cloned.

This class exists on on the client side which talks to remote session controller through RMI connection.

RemoteSessionController sits between the remote session and the session.

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 Purpose: A generic super class for AttributeGroup and other subclasses

INTERNAL A abstraction of converter capturing behavior common to all persistence types.

INTERNAL A abstraction of descriptor event 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 login capturing behavior common to all persistence types.

INTERNAL A abstraction of project capturing behavior common to all persistence types.

INTERNAL A abstraction of session event listener capturing behavior common to all persistence types.

One of the aggregate functions.

One of the aggregate functions.

Purpose: Stream class which is used to deal with large collections returned from TOPLink queries more efficiently.

Purpose: Abstract class for all Cursor-related policy objects

PUBLIC: Defines a user defined partitioning policy.

PUBLIC: A CacheInvalidationPolicy that allows objects to expire every day at a specific time.

PUBLIC: Defines the API for integration with a database event notification service.

Purpose: Wrapper for any database exception that occurred through EclipseLink.

Purpose: Hold the configuration information necessary to connect to a JDBC driver.

DatabasePlatform is private to EclipseLink.

Used for parameter retreival in JPQL

Purpose: Add login and configuration API to that of Session.

Purpose: Concrete class used for executing non selecting SQL strings.

PUBLIC: Defines the API for the integration with an external DataSources data partitioning support.

JPA scripting API implementation.

The query BNF for a date/time expression.

The query BNF for a date/time primary expression.

The query BNF for a date/time/timestamp expression.

Purpose: Provides DB2 specific behavior.

Purpose: Provides DBase specific behavior.

INTERNAL: Purpose:

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 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.

The default implementation of a ICaseExpressionStateObjectBuilder.

Purpose:Use this Connector to build a java.sql.Connection in the "standard" fashion, via the DriverManager.

This visitor traverses the JPQL parsed tree and gathers the possible proposals at a given position.

An implementation of IJPQLQueryBuilder that provides support based on the latest release of the Java Persistence functional specification.

This validator is responsible to validate a JPQL query grammatically purely based on the JPA specification document.

An implementation of IJPQLQueryBuilder that provides support based on the latest release of the Java Persistence functional specification.

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 visitor traverses an Expression and retrieves the "literal" value.

This visitor calculates the type of an input parameter.

The default implementation of RefactoringDelta which contains the TextEdit that were creating during the refactoring of a JPQL query.

The default implementation of a ResolverBuilder, which follows the JPA functional specification.

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: Default log used for the session when message logging is enabled.

The default implementation of BasicStateObjectBuilder, which provides support for creating a StateObject representation of any Expression.

DefaultTableGenerator is a utility class used to generate a default table schema for a EclipseLink project object.

Purpose:Provide a default implementation of the UnmappedContentHandler

Class called to transform Java names to XML names.

A DeleteAll annotation is specified to indicate that when an relationship is deleted, it should use a delete all query.

This is the delete clause of the delete statement.

This DeleteClauseFactory creates a new DeleteClause when the portion of the query to parse starts with DELETE FROM.

This is the DELETE clause of the DELETE statement.

Bulk delete operation apply to entities of a single entity class (together with its subclasses, if any).

This DeleteStatementFactory creates a new DeleteStatement when the portion of the query to parse starts with DELETE FROM.

Purpose: Provides Derby DBMS specific behavior.

This DerivedDeclaration represents an identification variable declaration that was declared in the FROM clause of a SELECT subquery.

BNF: subselect_identification_variable_declaration ::= derived_path_expression [AS] identification_variable {join}*

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: Used to support Java event listener event model on descriptors.

Purpose: This exception is used for any problem that is detected with a descriptor or mapping.

Purpose: The query manager allows for the database operations that EclipseLink performs to be customized by the application.

Purpose: This mapping is used to store a collection of simple types (String, Number, Date, etc.) into a single table.

Purpose:Use this Connector to build a java.sql.Connection by directly instantiating the Driver, as opposed to using the DriverManager.

Mapping for a collection of key-value pairs.

Purpose: Concrete class to perform a direct read.

Purpose: Maps an attribute to the corresponding database field type.

Instances of this exception are raised if a problem is detected during the discovery of a TopLink cluster.

Purpose: Detects new members of a logical EclipseLink cluster.

JPA scripting API implementation.

Purpose: Super class to all remote client session's.

TODO: BNF: arithmetic_expression ::= arithmetic_expression / arithmetic_term

Purpose: This should only be used by the descriptor, this should not be executed directly.

DOMRecord is an extension of the JCA Record interface that provides support for XML data.

This custom ClassLoader provides support for dynamically generating classes within an EclipseLink application using byte codes created using a DynamicClassWriter.

Write the byte codes of a dynamic entity class.

DynamicEntity is the public interface for dealing with dynamic persistent objects.

Custom exception type that provides information about failure cases encountered when using a GenericEntity with TopLink.

A SessionCustomizer which configures all descriptors as dynamic entity types.

A specialized JAXBContext for marshalling and unmarshalling DynamicEntities.

Extended SchemaManager to handle the creation of tables for dynamic types.

The EntityTypeBuilder is a factory class for creating and extending dynamic entity types.

MetadataSource used in the creation of dynamic JAXB contexts for applications in JPARS v2.0.

This visitor allows a subclass to simply override AnonymousExpressionVisitor.visit(Expression) and perform the same task for all visited expressions including those defined by EclipseLink.

This extension over the default content assist visitor adds the additional support EclipseLink provides.

Purpose: Any exception raised by EclipseLink should be a subclass of this exception class.

This validator adds EclipseLink extension over what the JPA functional specification had defined.

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.6.

This context is used to store information related to the 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: 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.

INTERNAL:

This refactoring tool add support for EclipseLink specific extension over the default implementation of JPQL defined in the Java Persistence functional specification.

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.

An enumeration listing the various releases of EclipseLink.

INTERNAL: Capture the changes for an unordered collection as collections of adds and removes.

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 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 EISDescriptor defines the mapping from a JCA data structure to a Java object.

An EISDOMRecord is a wrapper for a DOM tree.

INTERNAL: English ResourceBundle for EISException messages.

An EISLogin defines connection information and datasource properties.

INTERNAL All mappings which can be added to org.eclipse.persistence.eis.EISDescriptor must implement this interface.

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.

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.

Purpose: To provide API into the EISCollectionChangeSet.

The EISSequence class allows access to sequence resources using custom read (ValueReadQuery) and update (DataModifyQuery) queries and a user specified preallocation size.

JPA scripting API implementation.

The query BNF for a else expression specified in the case expression.

INTERNAL Common interface to those mappings that are used to map JPA Embedded objects.

JPA scripting API implementation.

The query BNF for an empty collection comparison expression.

An EmptyIterable is just that.

This Expression represents an identification variable that maps a Map property, either the key, the value or a Map.Entry).

JPA scripting API implementation.

JPA scripting API implementation.

The query BNF for a entity or value expression.

Entity resource.

JPA scripting API implementation.

The query BNF for the TYPE expression.

The query BNF for the entity type literal.

This StateObject wraps the name of an entity type.

This EntryExpressionFactory creates a new EntryExpression when the portion of the query to parse starts with ENTRY.

JPA scripting API implementation.

The query BNF for an enumeration constant expression.

The query BNF for an enum primary expression.

INTERNAL:

Exception handler can catch errors that occur on queries or during database access.

INTERNAL: English ResourceBundle for EclipseLinkException messages.

This property could be specified while creating either EntityManagerFactory (createEntityManagerFactory or persistence.xml) or EntityManager (createEntityManager); the latter overrides the former.

An enum that is used within the ExistenceChecking annotation.

The query BNF for the exists expression.

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.

This is the root interface of the parsed tree representation of a JPQL query.

An ExpressionFactory is responsible to parse a portion of JPQL query which starts with one of the factory's JPQL identifiers.

Purpose: ADVANCED: The expression operator is used internally to define SQL operations and functions.

A utility class containing various methods related to the Hermes parser.

This ExpressionVisitor wraps another ExpressionVisitor and delegates all its calls to it (the delegate).

Purpose: Interface for external transaction management.

The query BNF for the EXTRACT function.

Common interface for all response builders.

This interface represents a set of JPARS features.

The legacy initial feature set.

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.

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.

A FetchGroup is a performance enhancement that allows a group of attributes of an object to be loaded on demand, which means that the data for an attribute might not loaded from the underlying data source until an explicit access call for the attribute first occurs.

Purpose: Provide a very simple low overhead means for measuring fetch group field usage.

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.

Purpose: Define a database field definition for creation within a table.

JPA scripting API implementation.

Filter for fields filtering (projection) feature.

Type of fields filter.

PUBLIC: This interface is used by the Transformation Mapping to build the value for a specific field.

Purpose: Support serializing/deserializing a project representing application metadata to/from a file.

INTERNAL: Purpose: Provide common file I/O utilities

FlushClearCache persistence property defines modes of cache handling after em.flush call followed by em.clear call.

Purpose: Define a foreign key from one table to another.

Purpose: Define an alias to a foreign object.

Use this type of MarshalRecord when the marshal target is a Writer and the XML should be formatted with carriage returns and indenting.

The query BNF for the from clause.

The FROM clause of a query defines the domain of the query by declaring identification variables.

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.

The query BNF for the EclipseLink's function expression.

The number of parameters a FunctionExpression can have.

The query BNF for the parameters of a function expression.

The query BNF for a function expression returning a numeric value.

The query BNF for a general case expression.

The query BNF for a general identification variable expression.

INTERNAL:

An implementation of SemanticValidatorHelper that uses JPQLQueryContext to return the required information and Hermes SPI.

PUBLIC: This is the concrete subclass responsible for representing Glassfish server behavior.

Purpose: Provide a dynamic interface into the EclipseLink Session.

The GROUP BY construct enables the aggregation of values according to the properties of an entity class.

This GroupByClauseFactory creates a new GroupByClause when the portion of the query to parse starts with GROUP BY.

The query BNF for a group by item expression.

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.

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 query BNF for the having clause.

The HAVING construct enables conditions to be specified that further restrict the query result as restrictions upon the groups.

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.

Purpose:Expresses how historical data is saved on the data store.

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 can be used to easily create a conditional expression without having to create each object manually.

JPA scripting API implementation.

The query BNF for an identification variable expression.

The query BNF for an identification variable declaration expression.

An identification variable is a valid identifier declared in the FROM clause of a query.

This Resolver is responsible to resolve the type of an identification variable.

A role describes the purpose of the JPQL identifier.

EclipseLink helper class used for converting composite key values passed into JAX-RS calls as query or matrix parameters into a value that can be used in a find.

IDResolver can be subclassed to allow customization of the ID/IDREF processing of JAXBUnmarshaller.

IdValidation configures which id values are considered valid when loading from the database.

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 @Entity.

This builder is responsible to create an editable StateObject representation of a JPQL query.

This enumeration determines how the JPQL identifiers are formatted when written out.

This enumeration lists the possible modification a list can have.

The external representation of a managed type, which is a JPA persistent object.

The interface is used to visit a IManagedType.

The external representation of a mapping, which represents a single persistence property of a managed type.

This enumeration lists the mapping types defined in the Java Persistence functional specification.

JPA scripting API implementation.

Defines the specification for a call to a JCA interaction that uses indexed records.

The INDEX function returns an integer value corresponding to the position of its argument in an ordered list.

The INDEX function returns an integer value corresponding to the position of its argument in an ordered list.

Provides factory methods to create JDK specific implementation of particular type of IndirectCollection.

Purpose: Define an interface for a Container that can also act as an EclipseLink "indirection" object; i.e.

IndirectMap allows a domain class to take advantage of TopLink indirection without having to declare its instance variable as a ValueHolderInterface.

The query BNF for an in expression.

This InExpressionFactory creates a new InExpression when the portion of the query to parse starts with IN or NOT IN.

The state field path expression must have a string, numeric, or enum value.

Purpose: Provides Informix specific behavior.

Purpose: Allows customization of an object's inheritance.

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.

The query BNF for a input parameter.

Purpose: Used for inserting new objects into the database.

An InstantiationCopyPolicy is used to set an org.eclipse.persistence.descriptors.copying.InstantiationCopyPolicy on an Entity.

JPA scripting API implementation.

Purpose: IntegrityExceptions is used to throw all the Descriptors exceptions.

The query BNF for the parameter of an aggregate expression.

The query BNF for the parameters defined in the coalesce 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 FROM declaration, basically what follows the FROM identifier.

The query BNF for the parameter of the LENGTH expression.

The query BNF for the third parameter of the LOCATE expression.

The query BNF for the parameters of the MOD expression.

The query BNF for an order by item.

The query BNF for the position parameters of the SUBSTRING expression.

The query BNF for what's following the update identifier.

The query BNF for the expression following the WHEN identifier.

A IPropertyChangeListener can be registered with a StateObject in order to be notified when the value of a property changes.

This builder can be used to easily create a scalar 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.

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.

Makes the ItemLinks class available in our Dynamic JAXB context.

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:

INTERNAL:

INTERNAL:

Purpose: JavaModel representation of a java.lang.reflect.Constructor object.

INTERNAL:

INTERNAL:

PUBLIC:

INTERNAL:

INTERNAL:

INTERNAL:

INTERNAL:

Plain old Java serialization.

Java class for anonymous complex type.

INTERNAL

Purpose:Provide a EclipseLink implementation of the JAXBContext interface.

Purpose:An EclipseLink specific JAXBContextFactory.

This implementation of commonj.sdo.helper.DataFactory is responsible for ensuring that newly created DataObjects are assigned a JAXB aware value store.

Implementation of org.xml.sax.ErrorHandler.

INTERNAL: Purpose:

The JAXBHelperContext is a bridge between POJOs and SDO DataObjects.

JAXBList wraps the POJOs collection in order to provide additional SDO information.

INTERNAL:

Class used to log warnings during the processing of JAXB annotations and OXM XML bindings files.

Purpose: JAXBTypesafeEnumConverter is used to allow mapping to type safe enums according to the JAXB 1.0 spec.

Implementation of UnmarshallerHandler to be used by JAXBUnmarshaller.

Facilitates JAXBValidation.

This implementation of commonj.sdo.helper.XMLHelper is responsible for ensuring that newly unmarshalled DataObjects are assigned a JAXB aware value store.

Purpose: An implementation of XMLParser using JAXP 1.3 APIs.

Purpose: An implementation of XMLTransformer using JAXP 1.3 APIs.

Purpose: Provide a dynamic interface into the EclipseLink Session.

PUBLIC: Marker interface for JDBC type metadata

Purpose: Provide a transport implementation for the Remote Command Module (RCM) that publishes to a JGroup channel.

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 both publishes and subscribes to a JMS topic.

PUBLIC: Subclass of org.eclipse.persistence.platform.server.ServerPlatformBase in support of the JMXEnabledPlatform interface

A JOIN enables the fetching of an association as a side effect of the execution of a query.

The query BNF for the join expression.

JPA scripting API implementation.

A JoinFetch annotation can be used on any relationship mapping, (OneToOne, ManyToOne, OneToMany, ManyToMany, BasicCollection, BasicMap).

An enum type that is used within the JoinFetch annotation.

A JOIN enables the fetching of an association as a side effect of the execution of a query.

Purpose: TransactionController implementation for JOTM

PUBLIC: EclipseLInk specific JPA Criteria interface.

Purpose: Defines the Interface for EclipseLink extensions to the EntityManagerFactory

PUBLIC: EclipseLInk specific JPA query interface.

Logger for EclipseLink JPA-RS related functionality.

Purpose: Used as an abstraction of a database invocation.

INTERNAL: English ResourceBundle for EJBQLException.

A JPQL grammar defines how a JPQL query can be parsed.

This JPQLGrammar provides support for parsing JPQL queries defined in JSR-337 - Java Persistence 2.0.

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-337 - Java Persistence 2.0.

This builder wraps another builder and simply delegates the calls to it.

A JPQLQueryDeclaration represents either an identification variable declaration or a collection member declaration.

A problem describes an issue found in a JPQL query because it is either grammatically or semantically incorrect.

The resource bundle containing the problems encountered in a JPQL query.

The query BNF for the JPQL expression.

Uses EclipseLink Moxy to convert an object to JSON.

JSONWithPadding is used to hold an Object along with the corresponding callback name to marshal.

Purpose: Synchronization object implementation for JTA 1.0

This KeyExpressionFactory creates a new KeyExpression when the portion of the query to parse starts with KEY.

This Resolver is responsible to return the map key, which means that for identification variables referring to an instance of an association or collection represented as a Map, the identification variable is of the abstract schema type of the map key.

This KeywordExpressionFactory creates a new KeywordExpression when the portion of the JPQL query to parse is FALSE, TRUE or NULL.

Uses Kryo to serialize the object.

This LengthExpressionFactory creates a new LengthExpression when the portion of the query to parse starts with LENGTH.

The LIKE condition is used to specify a search for a pattern.

This BNF is used when parsing an invalid fragment or to extend the default grammar.

The LIKE condition is used to specify a search for a pattern.

This class is used to wrap collection of Link objects

Makes the LinkV2 class available in our Dynamic JAXB context.

INTERNAL: A ListExpressionOperator is used with an ArgumentListFunctionExpression.

A ListIterable simply forces the returned object to be an instance of ListIterator.

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.

Some Expression can have a "literal", this enumeration is used to visit an Expression and to retrieve the right value.

Purpose: Used to load specified relationship attributes and nested relationship attributes.

The LOCATE function returns the position of a given string within a string, starting the search at a specified position.

The LOCATE function returns the position of a given string within a string, starting the search at a specified position.

Logger type persistence property values.

This expression represents a logical expression, which means the first and second expressions are aggregated with either the AND or the OR operator.

The LOWER function converts a string to lower case and it returns a string.

The LOWER function converts a string to lower case and it returns a string.

Purpose: Many to many mappings are used to represent the relationships between a collection of source objects and a collection of target objects.

JPA scripting API implementation.

Purpose: Define a change event for Map types.

JPA scripting API implementation.

Class for wrapping cache key lookup results.

Defines the specification for a call to a JCA interaction using Mapped records.

JPA scripting API implementation.

INTERNAL:

A MarshalRecord encapsulates the marshal target.

One of the aggregate functions.

One of the aggregate functions.

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 remote command implementation for remote cache merges of changes.

You may subclass this class rather than implement the MetadataSource interface allowing insulation from future additions to the interface.

Purpose: Allows a class to be a QueryRedirector without implementing QueryRedirector.

This MinFunctionFactory creates a new MinFunction when the portion of the query to parse starts with MIN.

The modulo operation finds the remainder of division of one number by another.

The modulo operation finds the remainder of division of one number by another.

Purpose: Abstract class for all modify queries.

TODO: BNF: arithmetic_expression ::= arithmetic_expression * arithmetic_term

JPA scripting API implementation.

Purpose: Maps a multitenant property to the corresponding database field type.

A Mutable annotation can be used on a @Basic mapping.

JPA scripting API implementation.

JPA scripting API implementation.

A NamedPLSQLStoredProcedureQueries annotation allows the definition of multiple NamedPLSQLStoredProcedureQuery.

A PLSQLNamedStoredProcedureQuery annotation allows the definition of queries that call PLSQL stored procedures as named queries.

A NamedStoredFunctionQueries annotation allows the definition of multiple NamedStoredFunctionQuery.

JPA scripting API implementation.

A NamedStoredProcedureQuery annotation allows the definition of queries that call stored procedures as named queries.

INTERNAL:

It is common for an XML document to include one or more namespaces.

Purpose: Define a database's native sequencing mechanism.

This class can be used to define the dataType with an ObjectTypeConverter to have EclipseLink bind the object string value as an NCLOB Oracle type.

Purpose: Nested tables are similar to VARRAYs except internally they store their information in a separate table from their parent structure's table.

Purpose:Provide a policy that specifies how new XML Elements are added to an existing XML Document.

PUBLIC: A cache invalidation policy in which no objects will expire.

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.

This NotExpressionFactory creates a new NotExpression when the portion of the query to parse starts with NOT.

This class can be used to define the dataType with an ObjectTypeConverter to have EclipseLink bind the object string value as an NCLOB Oracle type.

The query BNF for a null comparison expression.

A null Expression is used instead of a true null, which allows operations to be performed without doing a null check first.

NULLIF returns the first expression if the two expressions are not equal.

This NullIfExpressionFactory creates a new NullIfExpression when the portion of the query to parse starts with NULLIF.

PUBLIC: Description: This null policy is the default implementation class.
Marshal:
The boolean value of the isSet() state of a node has no effect on whether a node will be written out for a null value - a set is always performed unless the isSetPerformedForAbsentNode flag is set to false for absent nodes.
Unmarshal:

Exact numeric literals support the use of Java integer literal syntax as well as SQL exact numeric literal syntax.

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.

Purpose: Abstract class for all read queries that build objects and potentially manipulate the TopLink cache.

Purpose: Provides API to the Class that holds all changes made to a particular Object.

The query BNF for an object expression.

Stand-alone identification variables in the SELECT clause may optionally be qualified by the OBJECT operator.

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.

Purpose: Abstract class for all object modify queries.

Purpose: Provides API for the ObjectReferenceChangeRecord.

INTERNAL: A database field of object-relational type: either a java.sql.Array, java.sql.Struct, or java.sql.Ref.

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.

Purpose: Object type converter is used to match a fixed number of database data values to Java object value.

Purpose: Allow for creation of object varray type.

Purpose: TransactionController implementation for OC4J JTA

The query BNF for the on clause.

JPA scripting API implementation.

Purpose:Represents a 1-m join query.

Purpose: One to one mappings are used to represent a pointer references between two java objects.

Utility class used for processing an XPath Expression into postfix notation.

INTERNAL: English ResourceBundle for OptimisticLockException messages.

JPA scripting API implementation.

Purpose: Supports usage of certain Oracle JDBC specific APIs.

Purpose: Supports usage of certain Oracle JDBC specific APIs for the Oracle 12 database.

Purpose: Supports usage of certain Oracle JDBC specific APIs.

An OracleArray annotation is used to define an Oracle database VARRAY type.

PUBLIC: This class allows connection to open proxy session.

An OracleObject annotation is used to define an Oracle database OBJECT type.

Purpose: Provides Oracle specific behavior.

PUBLIC: Oracle PL/SQL types

The query BNF for the order by clause.

The ORDER BY clause allows the objects or values that are returned by the query to be ordered.

This enumeration lists all the possible choices for ordering nulls in an item.

The query BNF for the order by item expression.

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.

OrderCorrection annotation may be specified together with OrderColumn annotation.

In a hierarchical query, if the rows of siblings of the same parent need to be ordered, then the ORDER SIBLINGS BY clause should be used.

This OrderSiblingsByClauseFactory creates a new OrderSiblingsByClause when the portion of the query to parse starts with ORDER SIBLINGS BY.

This OrExpressionFactory creates a new OrExpression when the portion of the query to parse starts with OR.

Use this type of MarshalRecord when the marshal target is an OutputStream and the XML should not be formatted with carriage returns or indenting.

INTERNAL:

INTERNAL:

INTERNAL:

INTERNAL:

INTERNAL:

INTERNAL: Represents the the package level annotations from a specific package.

Finds out if an entity field is pageable and validates paging parameters.

FeatureResponseBuilder implementation used for pageable collections.

This visitor calculates the type of an input parameter.

Parser type property values.

A Partitioning is used to partition the data for a class across multiple difference databases or across a database cluster such as Oracle RAC.

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: A tool used to provide performance monitoring information in a server environment.

A wrapper around the JPA and JAXB artifacts used to persist an application.

Manages the PersistenceContexts that are used by a JPA-RS deployment.

Persistence units catalog resource (JPARS version 2.0 and above).

JPA scripting API implementation.

JPA scripting API implementation.

Metadata catalog resource in JPARS version less than 2.0.