@(#)eclipselink_orm_2_3.xsd 2.3 March 23 2011
...
]]>
/**
* An additional criteria can be specified at the Entity or MappedSuperclass
* level. When specified at the mapped superclass level, it applies to all
* inheriting entities unless those entities define their own additional
* criteria, at which point the additional criteria from the mapped superclass
* is ignored.
*
* The additional criteria supports any valid JPQL string and must use 'this'
* as an alias to form your additional criteria. E.G.,
*
* @Entity
* @AdditionalCriteria("this.nut.size = :NUT_SIZE and this.nut.color = :NUT_COLOR")
* public class Bolt {...}
*
* Additional criteria parameters are also accepted and are set through
* properties on the entity manager factory, or on an entity manager. When set
* on the entity manager, the properties must be set before any query execution
* and should not be changed for the life span of that entity manager.
*
* Properties set on the entity manager will override those similarly named
* properties set on the entity manager factory.
*
* Additional criteria is not supported with any native queries.
*
* @author Guy Pelletier
* @since EclipseLink 2.2
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface AdditionalCriteria {
/**
* (Required) The JPQL fragment to use as the additional criteria.
*/
String value();
}
/**
* The Cache annotation is used to set an
* org.eclipse.persistence.descriptors.invalidation.CacheInvalidationPolicy
* which sets objects in EclipseLink's identity maps to be invalid
* following given rules. By default in EclipseLink, objects do not
* expire in the cache. Several different policies are available to
* allow objects to expire.
*
* @see org.eclipse.persistence.annotations.CacheType
*
* A Cache anotation may be defined on an Entity or MappedSuperclass.
* In the case of inheritance, a Cache annotation should only be defined
* on the root of the inheritance hierarchy.
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface Cache {
/**
* (Optional) The type of cache to use.
*/
CacheType type() default SOFT_WEAK;
/**
* (Optional) The size of cache to use.
*/
int size() default 100;
/**
* (Optional) Cached instances in the shared cache,
* or only a per EntityManager isolated cache.
* The default is shared.
* @deprecated As of Eclipselink 2.2. See the attribute 'isolation'
*/
@Deprecated
boolean shared() default true;
/**
* (Optional) Controls the level of caching this Entity will use.
* The default is CacheIsolationType.SHARED which has EclipseLink
* Caching all Entities in the Shared Cache.
* @see org.eclipse.persistence.config.CacheIsolationType
*/
CacheIsolationType isolation() default SHARED;
/**
* (Optional) Expire cached instance after a fix period of time (ms).
* Queries executed against the cache after this will be forced back
* to the database for a refreshed copy
*/
int expiry() default -1; // minus one is no expiry.
/**
* (Optional) Expire cached instance a specific time of day. Queries
* executed against the cache after this will be forced back to the
* database for a refreshed copy
*/
TimeOfDay expiryTimeOfDay() default @TimeOfDay(specified=false);
/**
* (Optional) Force all queries that go to the database to always
* refresh the cache.
*/
boolean alwaysRefresh() default false;
/**
* (Optional) For all queries that go to the database, refresh the
* cache only if the data received from the database by a query is
* newer than the data in the cache (as determined by the optimistic
* locking field)
*/
boolean refreshOnlyIfNewer() default false;
/**
* (Optional) Setting to true will force all queries to bypass the
* cache for hits but still resolve against the cache for identity.
* This forces all queries to hit the database.
*/
boolean disableHits() default false;
/**
* (Optional) The cache coordination mode.
*/
CacheCoordinationType coordinationType() default SEND_OBJECT_CHANGES;
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface CacheInterceptor {
Class value();
}
/**
* The CacheType enum is used with the Cache annotation for a
* persistent class. It defines the type of IdentityMap/Cache used for
* the class. By default the SOFT_WEAK cache type is used.
*
* @see org.eclipse.persistence.annotations.Cache
*/
public enum CacheType {
/**
* Provides full caching and guaranteed identity. Caches all objects
* and does not remove them.
* WARNING: This method may be memory intensive when many objects are
* read.
*/
FULL,
/**
* Similar to the FULL identity map except that the map holds the
* objects using weak references. This method allows full garbage
* collection and provides full caching and guaranteed identity.
*/
WEAK,
/**
* Similar to the FULL identity map except that the map holds the
* objects using soft references. This method allows full garbage
* collection when memory is low and provides full caching and
* guaranteed identity.
*/
SOFT,
/**
* Similar to the WEAK identity map except that it maintains a
* most-frequently-used sub-cache. The size of the sub-cache is
* proportional to the size of the identity map as specified by
* descriptor's setIdentityMapSize() method. The sub-cache
* uses soft references to ensure that these objects are
* garbage-collected only if the system is low on memory.
*/
SOFT_WEAK,
/**
* Identical to the soft cache weak (SOFT_WEAK) identity map except
* that it uses hard references in the sub-cache. Use this identity
* map if soft references do not behave properly on your platform.
*/
HARD_WEAK,
/**
* A cache identity map maintains a fixed number of objects
* specified by the application. Objects are removed from the cache
* on a least-recently-used basis. This method allows object
* identity for the most commonly used objects.
* WARNING: Furnishes caching and identity, but does not guarantee
* identity.
*/
CACHE,
/**
* WARNING: Does not preserve object identity and does not cache
* objects.
*/
NONE
}
/**
* Options for how Entity instances should be shared within an EclipseLink Persistence Unit / ServerSession
* @see ClassDescriptor#setCacheIsolationType(CacheIsolationType)
* @author Gordon Yorke
* @since EclipseLink 2.2
*/
public enum CacheIsolationType {
/**
* Entity instances will be cached within the EntityManagerFactory/ServerSession level.
* Any user queries for shared cache instances (ie Read-Only query hint) will return an Entity
* instance that may be shared by multiple clients.
*
* This setting is the default isolation level.
*/
SHARED,
/**
* Entity state information will be cached in the shared cache but Entity
* instances will not be shared. Any user queries for shared cache instances
* (ie Read-Only query hint) will return a new Entity instance with the cached state.
* This will ensure the instance is protected from any concurrent
* state change.
*/
PROTECTED,
/**
* The Entity and its data is not stored in the shared cache but is
* isolated to the Persistence Context/UnitOfWork or
* IsolatedClientSession. This setting effectively disables second level
* caching for this entity and should be used when users do not want caching for
* a particular Entity.
*/
ISOLATED;
}
/**
* An enum that is used within the Cache annotation.
*
* @see org.eclipse.persistence.annotations.Cache
*/
public enum CacheCoordinationType {
/**
* Sends a list of changed objects including data about the changes.
* This data is merged into the receiving cache.
*/
SEND_OBJECT_CHANGES,
/**
* Sends a list of the identities of the objects that have changed.
* The receiving cache invalidates the objects (rather than changing
* any of the data)
*/
INVALIDATE_CHANGED_OBJECTS,
/**
* Same as SEND_OBJECT_CHANGES except it also includes any newly
* created objects from the transaction.
*/
SEND_NEW_OBJECTS_WITH_CHANGES,
/**
* Does no cache coordination.
*/
NONE
}
/**
* The ChangeTracking annotation is used to specify the
* org.eclipse.persistence.descriptors.changetracking.ObjectChangePolicy
* which computes changes sets for EclipseLink's UnitOfWork commit
* process. An ObjectChangePolicy is stored on an Entity's descriptor.
*
* A ChangeTracking annotation may be specified on an Entity,
* MappedSuperclass or Embeddable.
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface ChangeTracking {
/**
* (Optional) The type of change tracking to use.
*/
ChangeTrackingType value() default AUTO;
}
/**
* An enum that is used within the ChangeTracking annotation.
*/
public enum ChangeTrackingType {
/**
* An ATTRIBUTE change tracking type allows change tracking at the
* attribute level of an object. Objects with changed attributes will
* be processed in the commit process to include any changes in the
* results of the commit. Unchanged objects will be ignored.
*/
ATTRIBUTE,
/**
* An OBJECT change tracking policy allows an object to calculate for
* itself whether it has changed. Changed objects will be processed in
* the commit process to include any changes in the results of the
* commit. Unchanged objects will be ignored.
*/
OBJECT,
/**
* A DEFERRED change tracking policy defers all change detection to
* the UnitOfWork's change detection process. Essentially, the
* calculateChanges() method will run for all objects in a UnitOfWork.
* This is the default ObjectChangePolicy
*/
DEFERRED,
/**
* Will not set any change tracking policy.
*/
AUTO
}
/**
* The Customizer annotation is used to specify a class that implements
* the org.eclipse.persistence.config.DescriptorCustomizer
* interface and is to run against an enetity's class descriptor after all
* metadata processing has been completed.
*
* The Customizer annotation may be defined on an Entity, MappedSuperclass
* or Embeddable class. In the case of inheritance, a Customizer is not
* inherited from its parent classes.
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface Customizer {
/**
* (Required) Defines the name of the descriptor customizer class that
* should be applied for the related entity or embeddable class.
*/
Class value();
}
/**
* An enum that is used within the StoredProcedureParameter annotation.
* It is used to specify the direction of the stored procedure
* parameters of a named stored procedure query.
*/
public enum Direction {
/**
* Input parameter
*/
IN,
/**
* Output parameter
*/
OUT,
/**
* Input and output parameter
*/
IN_OUT,
/**
* Output cursor
*/
OUT_CURSOR
}
The entity-mappings element is the root element of a mapping
file. It contains the following four types of elements:
1. The persistence-unit-metadata element contains metadata
for the entire persistence unit. It is undefined if this element
occurs in multiple mapping files within the same persistence unit.
2. The package, schema, catalog and access elements apply to all of
the entity, mapped-superclass and embeddable elements defined in
the same file in which they occur.
3. The sequence-generator, table-generator, named-query,
named-native-query and sql-result-set-mapping elements are global
to the persistence unit. It is undefined to have more than one
sequence-generator or table-generator of the same name in the same
or different mapping files in a persistence unit. It is also
undefined to have more than one named-query, named-native-query, or
result-set-mapping of the same name in the same or different mapping
files in a persistence unit.
4. The entity, mapped-superclass and embeddable elements each define
the mapping information for a managed persistent class. The mapping
information contained in these elements may be complete or it may
be partial.
/**
* The ExistenceChecking annotation is used to specify the type of
* checking EclipseLink should use when updating entities.
*
* An existence-checking specification is supported on an Entity or
* MappedSuperclass annotation.
*/
public @interface ExistenceChecking {
/**
* (Optional) Set the existence check for determining
* if an insert or update should occur for an object.
*/
ExistenceType value() default CHECK_CACHE;
}
/**
* Assume that if the objects primary key does not include null and
* it is in the cache, then it must exist.
*/
CHECK_CACHE,
/**
* Perform does exist check on the database.
*/
CHECK_DATABASE,
/**
* Assume that if the objects primary key does not include null then
* it must exist. This may be used if the application guarantees or
* does not care about the existence check.
*/
ASSUME_EXISTENCE,
/**
* Assume that the object does not exist. This may be used if the
* application guarantees or does not care about the existence check.
* This will always force an insert to be called.
*/
ASSUME_NON_EXISTENCE
Metadata that applies to the persistence unit and not just to
the mapping file in which it is contained.
If the xml-mapping-metadata-complete element is specified,
the complete set of mapping metadata for the persistence unit
is contained in the XML mapping files for the persistence unit.
These defaults are applied to the persistence unit as a whole
unless they are overridden by local annotation or XML
element settings.
schema - Used as the schema for all tables, secondary tables, join
tables, collection tables, sequence generators, and table
generators that apply to the persistence unit
catalog - Used as the catalog for all tables, secondary tables, join
tables, collection tables, sequence generators, and table
generators that apply to the persistence unit
delimited-identifiers - Used to treat database identifiers as
delimited identifiers.
access - Used as the access type for all managed classes in
the persistence unit
cascade-persist - Adds cascade-persist to the set of cascade options
in all entity relationships of the persistence unit
entity-listeners - List of default entity listeners to be invoked
on each entity in the persistence unit.
Defines the settings and mappings for an entity. Is allowed to be
sparsely populated and used in conjunction with the annotations.
Alternatively, the metadata-complete attribute can be used to
indicate that no annotations on the entity class (and its fields
or properties) are to be processed. If this is the case then
the defaulting rules for the entity and its subelements will
be recursively applied.
@Target(TYPE) @Retention(RUNTIME)
public @interface Entity {
String name() default "";
}
This element determines how the persistence provider accesses the
state of an entity or embedded object.
@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)
public @interface AssociationOverride {
String name();
JoinColumn[] joinColumns() default{};
JoinTable joinTable() default @JoinTable;
}
@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)
public @interface AttributeOverride {
String name();
Column column();
}
This element contains the entity field or property mappings.
It may be sparsely populated to include only a subset of the
fields or properties. If metadata-complete for the entity is true
then the remainder of the attributes will be defaulted according
to the default rules.
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Basic {
FetchType fetch() default EAGER;
boolean optional() default true;
}
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface BasicCollection {
/**
* (Optional) Defines whether the value of the field or property
* should be lazily loaded or must be eagerly fetched. The EAGER
* strategy is a requirement on the persistence provider runtime that
* the value must be eagerly fetched. The LAZY strategy is a hint to
* the persistence provider runtime. If not specified, defaults to
* LAZY.
*/
FetchType fetch() default LAZY;
/**
* (Optional) The name of the value column that holds the direct
* collection data. Defaults to the property or field name.
*/
Column valueColumn() default @Column;
}
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface BasicMap {
/**
* (Optional) Defines whether the value of the field or property
* should be lazily loaded or must be eagerly fetched. The EAGER
* strategy is a requirement on the persistence provider runtime that
* the value must be eagerly fetched. The LAZY strategy is a hint to
* the persistence provider runtime. If not specified, defaults to
* LAZY.
*/
FetchType fetch() default LAZY;
/**
* (Optional) The name of the data column that holds the direct map
* key. If the name on te key column is "", the name will default to:
* the name of the property or field; "_KEY".
*/
Column keyColumn() default @Column;
/**
* (Optional) Specify the key converter. Default is equivalent to
* specifying @Convert("none"), meaning no converter will be added to
* the direct map key.
*/
Convert keyConverter() default @Convert;
/**
* (Optional) The name of the data column that holds the direct
* collection data. Defaults to the property or field name.
*/
Column valueColumn() default @Column;
/**
* (Optional) Specify the value converter. Default is equivalent to
* specifying @Convert("none"), meaning no converter will be added to
* the value column mapping.
*/
Convert valueConverter() default @Convert;
}
public enum CascadeType { ALL, PERSIST, MERGE, REMOVE, REFRESH, DETACH};
/**
* A ClassExtractor allows for a user defined class indicator in place of
* providing a discriminator column. The class has the following restrictions:
* - It must extend the org.eclipse.persistence.descriptors.ClassExtractor
* class and implement the extractClassFromRow(Record, Session) method.
* - That method must take a database row (a Record/Map) as an argument and
* must return the class to use for that row.
*
* This method will be used to decide which class to instantiate when reading
* from the database. It is the application's responsibility to populate any
* typing information in the database required to determine the class from the
* row.
*
* The ClassExtractor must only be set on the root of an entity class or
* sub-hierarchy in which a different inheritance strategy is applied. The
* ClassExtractor can only be used with the SINGLE_TABLE and JOINED inheritance
* strategies.
*
* If a ClassExtractor is used then a DiscriminatorColumn cannot be used. A
* ClassExtractor also cannot be used on either the root or its subclasses.
*
* In addition, for more complex configurations using a ClassExtractor and a
* SINGLE_TABLE strategy, the descriptor's withAllSubclasses and onlyInstances
* expressions should be set through the ClassExtractor's initialize method.
*
* @see org.eclipse.persistence.descriptors.InheritancePolicy.setWithAllSubclassesExpression(Expression)
* @see org.eclipse.persistence.descriptors.InheritancePolicy.setOnlyInstancesExpression(Expression)
*
* @author Guy Pelletier
* @since EclipseLink 2.1
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface ClassExtractor {
/**
* (Required) Defines the name of the class extractor that should be
* applied to this entity's descriptor.
*/
Class value();
}
/**
* A CloneCopyPolicy is used to set an
* org.eclipse.persistence.descriptors.copying.CloneCopyPolicy on an
* Entity. A CloneCopyPolicy must specify at one or both of the "method"
* or "workingCopyMethod". "workingCopyMethod" is used to clone objects
* that will be returned to the user as they are registered in
* EclipseLink's transactional mechanism, the UnitOfWork. "method" will
* be used for the clone that is used for comparison in conjunction with
* EclipseLink's DeferredChangeDetectionPolicy
*
* A CloneCopyPolicy should be specified on an Entity, MappedSuperclass
* or Embeddable.
*
* Example:
* @Entity
* @CloneCopyPolicy(method="myCloneMethod")
*
* or:
*
* @Entity
* @CloneCopyPolicy(method="myCloneMethod", workingCopyMethod="myWorkingCopyCloneMethod")
*
* or:
*
* @Entity
* @CloneCopyPolicy(workingCopyMethodName="myWorkingCopyClone")
*/
public @interface CloneCopyPolicy {
/**
* (Optional)
* Either method or workingCopyMethod must be specified this defines
* a method that will be used to create a clone that will be used
* for comparison by
* EclipseLink's DeferredChangeDetectionPolicy
*/
String method();
/**
* (Optional)
* Either method or workingCopyMethod must be specified
* this defines a method that will be used to create a clone that
* will be used to create the object returned when registering an
* Object in an EclipseLink UnitOfWork
*/
String workingCopyMethod();
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface CollectionTable {
String name() default "";
String catalog() default "";
String schema() default "";
JoinColumn[] joinColumns() default {};
UniqueConstraint[] uniqueConstraints() default {};
}
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface CollectionTable {
/**
* (Optional) The name of the collection table. If it is not
* specified, it is defaulted to the concatenation of the following:
* the name of the source entity; "_" ; the name of the relationship
* property or field of the source entity.
*/
String name() default "";
/**
* (Optional) The catalog of the table. It defaults to the persistence
* unit default catalog.
*/
String catalog() default "";
/**
* (Optional) The schema of the table. It defaults to the persistence
* unit default schema.
*/
String schema() default "";
/**
* (Optional) Used to specify a primary key column that is used as a
* foreign key to join to another table. If the source entity uses a
* composite primary key, a primary key join column must be specified
* for each field of the composite primary key. In a single primary
* key case, a primary key join column may optionally be specified.
* Defaulting will apply otherwise as follows:
* name, the same name as the primary key column of the primary table
* of the source entity. referencedColumnName, the same name of
* primary key column of the primary table of the source entity.
*/
PrimaryKeyJoinColumn[] primaryKeyJoinColumns() default {};
/**
* (Optional) Unique constraints that are to be placed on the table.
* These are only used if table generation is in effect.
*/
UniqueConstraint[] uniqueConstraints() default {};
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Column {
String name() default "";
boolean unique() default false;
boolean nullable() default true;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
String table() default "";
int length() default 255;
int precision() default 0; // decimal precision
int scale() default 0; // decimal scale
}
@Target({})
@Retention(RUNTIME)
public @interface ConversionValue {
/**
* (Required) Specify the database value.
*/
String dataValue();
/**
* (Required) Specify the object value.
*/
String objectValue();
}
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface Converter {
/**
* (Required) Name this converter. The name should be unique across
* the whole persistence unit.
*/
String name();
/**
* (Required) The converter class to be used. This class must implement
* the org.eclipse.persistence.mappings.converters.Converter interface.
*/
Class converterClass();
}
/**
* A Partitioning is used to partition the data for a class across multiple difference databases
* or across a database cluster such as Oracle RAC.
* Partitioning can provide improved scalability by allowing multiple database machines to service requests.
* This annotation configures a custom PartitioningPolicy.
*
* If multiple partitions are used to process a single transaction, JTA should be used for proper XA transaction support.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
* Partition policies are globally named to allow reuse,
* the partitioning policy must also be set using the @Partitioned annotation to be used.
*
* @see Partitioned
* @see org.eclipse.persistence.descriptors.partitioning.PartitioningPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface Partitioning {
String name();
/**
* (Required) Full package.class name of a subclass of PartitioningPolicy.
*/
Class partitioningClass();
}
/**
* 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.
* The hash indexes into the list of connection pools.
* All write or read request for object's with that hash value are sent to the server.
* If a query does not include the field as a parameter, then it can either be sent
* to all server's and unioned, or left to the sesion's default behavior.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
*
* @see org.eclipse.persistence.descriptors.partitioning.HashPartitioningPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface HashPartitioning {
String name();
/**
* The database column or query parameter to partition queries by.
* This is the table column name, not the class attribute name.
* The column value must be included in the query and should normally be part of the object's Id.
* This can also be the name of a query parameter.
* If a query does not contain the field the query will not be partitioned.
*/
Column partitionColumn();
/**
* List of connection pool names to partition across.
*/
String[] connectionPools();
/**
* Defines if queries that do not contain the partition field should be sent
* to every database and have the result unioned.
*/
boolean unionUnpartitionableQueries() default false;
}
/**
* RangePartitioningPolicy partitions access to a database cluster by a field value from the object,
* such as the object's id, location, or tenant.
* Each server is assigned a range of values.
* All write or read request for object's with that value are sent to the server.
* If a query does not include the field as a parameter, then it can either be sent
* to all server's and unioned, or left to the sesion's default behavior.
*
* If multiple partitions are used to process a single transaction, JTA should be used for proper XA transaction support.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
* Partition policies are globally named to allow reuse,
* the partitioning policy must also be set using the @Partitioned annotation to be used.
*
* @see Partitioned
* @see org.eclipse.persistence.descriptors.partitioning.RangePartitioningPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface RangePartitioning {
String name();
/**
* The database column or query parameter to partition queries by.
* This is the table column name, not the class attribute name.
* The column value must be included in the query and should normally be part of the object's Id.
* This can also be the name of a query parameter.
* If a query does not contain the field the query will not be partitioned.
*/
Column partitionColumn();
/**
* (Required) List of connection pool names to load balance across.
*/
RangePartition[] partitions();
/**
* Defines if queries that do not contain the partition field should be sent
* to every database and have the result unioned.
*/
boolean unionUnpartitionableQueries() default false;
/** The type of the start and end values. */
Class partitionValueType() default String.class;
}
/**
* Represent a specific range partition.
* Values = startValue and = endValue will be routed to the connection pool.
*
* @see RangePartitioningPolicy
* @see org.eclipse.persistence.descriptors.partitioning.RangePartitioningPolicy
* @see org.eclipse.persistence.descriptors.partitioning.RangePartition
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface RangePartition {
/** The String representation of the range start value. */
String startValue() default "";
/** The String representation of the range start value. */
String endValue() default "";
/** The connection pool to route queries to for this range. */
String connectionPool();
}
/**
* ValuePartitioning partitions access to a database cluster by a field value from the object,
* such as the object's location, or tenant.
* Each value is assigned a specific server.
* All write or read request for object's with that value are sent to the server.
* If a query does not include the field as a parameter, then it can either be sent
* to all server's and unioned, or left to the sesion's default behavior.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
*
* @see org.eclipse.persistence.descriptors.partitioning.ValuePartitioningPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface ValuePartitioning {
String name();
/**
* The database column or query parameter to partition queries by.
* This is the table column name, not the class attribute name.
* The column value must be included in the query and should normally be part of the object's Id.
* This can also be the name of a query parameter.
* If a query does not contain the field the query will not be partitioned.
*/
Column partitionColumn();
/** Store the value partitions. Each partition maps a value to a connectionPool. */
ValuePartition[] partitions();
/** The type of the start and end values. */
Class partitionValueType() default String.class;
/** The default connection pool is used for any unmapped values. */
String defaultConnectionPool();
/**
* Defines if queries that do not contain the partition field should be sent
* to every database and have the result unioned.
*/
boolean unionUnpartitionableQueries() default false;
}
/**
* Represent a specific value partition.
* The value will be routed to the connection pool.
*
* @see ValuePartitioningPolicy
* @see org.eclipse.persistence.descriptors.partitioning.ValuePartitioningPolicy
* @see org.eclipse.persistence.descriptors.partitioning.ValuePartition
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface ValuePartition {
/** The String representation of the range start value. */
String value() default "";
/** The connection pool to route queries to for this value. */
String connectionPool();
}
/**
* RoundRobinPartitioning sends requests in a round robin fashion to the set of connection pools.
* It is for load-balancing read queries across a cluster of database machines.
* It requires that the full database be replicated on each machine, so does not support partitioning.
* The data should either be read-only, or writes should be replicated on the database.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
*
* @see org.eclipse.persistence.descriptors.partitioning.RoundRobinPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface RoundRobinPartitioning {
String name();
/**
* (Required) List of connection pool names to load balance across.
*/
String[] connectionPools();
/**
* This allows for a set of database to be written to and kept in synch,
* and have reads load-balanced across the databases.
*/
boolean replicateWrites() default false;
}
/**
* ReplicationPartitioning sends requests to a set of connection pools.
* It is for replicating data across a cluster of database machines.
* Only modification queries are replicated.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
*
* @see org.eclipse.persistence.descriptors.partitioning.ReplicationPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface ReplicationPartitioning {
String name();
/**
* (Required) List of connection pool names to load balance across.
*/
String[] connectionPools();
}
/**
* UnionPartitioning sends queries to all connection pools and unions the results.
* This is for queries or relationships that span partitions when partitioning is used,
* such as on a ManyToMany cross partition relationship.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
*
* @see org.eclipse.persistence.descriptors.partitioning.UnionPartitioningPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface UnionPartitioning {
String name();
/**
* (Required) List of connection pool names to load balance across.
*/
String[] connectionPools();
/**
* Defines if write queries should be replicated.
* Writes are normally not replicated when unioning,
* but can be for ManyToMany relationships, when the join table needs to be replicated.
*/
boolean replicateWrites() default false;
}
/**
* PinnedPartitioning pins requests to a single connection pool.
*
* Partitioning can be enabled on an Entity, relationship, query, or session/persistence unit.
*
* @see org.eclipse.persistence.descriptors.partitioning.PinnedPartitioningPolicy
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface PinnedPartitioning {
String name();
/**
* The connection pool name to pin queries to.
*/
String connectionPool();
}
@Target({}) @Retention(RUNTIME)
public @interface ColumnResult {
String name();
}
/**
* A CopyPolicy is used to set a
* org.eclipse.persistence.descriptors.copying.CopyPolicy on an Entity.
* It is required that a class that implements
* org.eclipse.persistence.descriptors.copying.CopyPolicy be specified
* as the argument.
*
* A CopyPolicy should be specified on an Entity, MappedSuperclass or
* Embeddable.
*
* For instance:
* @Entity
* @CopyPolicy("example.MyCopyPolicy")
*/
public @interface CopyPolicy {
/*
* (Required)
* This defines the class of the copy policy. It must specify a class
* that implements org.eclipse.persistence.descriptors.copying.CopyPolicy
*/
Class value();
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface DiscriminatorColumn {
String name() default "DTYPE";
DiscriminatorType discriminatorType() default STRING;
String columnDefinition() default "";
int length() default 31;
}
/**
* A DiscriminatorClass is used within a VariableOneToOne annotation.
*/
@Target({})
@Retention(RUNTIME)
public @interface DiscriminatorClass {
/**
* (Required) The discriminator to be stored on the database.
*/
String discriminator();
/**
* (Required) The class to the instantiated with the given
* discriminator.
*/
Class value();
}
public enum DiscriminatorType { STRING, CHAR, INTEGER };
@Target({TYPE}) @Retention(RUNTIME)
public @interface DiscriminatorValue {
String value();
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface ElementCollection {
Class targetClass() default void.class;
FetchType fetch() default LAZY;
}
/**
* Array types are extended object-relational data-types supported by some databases.
* Array types are user define types in the database such as VARRAY types on Oracle.
* Arrays can contains basic types (VARCHAR) or other Struct types, and can be stored in
* a column or in a Struct type.
* This annotation can be defined on a collection attribute that is
* persisted to an Array type. The collection can be of basic types, or embeddable
* class mapped using a Struct.
*
* @see org.eclipse.persistence.mappings.structures.ObjectRelationalDataTypeDescriptor
* @see org.eclipse.persistence.mappings.structures.ArrayMapping
* @see org.eclipse.persistence.mappings.structures.ObjectArrayMapping
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Array {
/**
* (Optional) The basic or embeddable class that is the element
* type of the collection. This element is optional only if the
* collection field or property is defined using Java generics,
* and must be specified otherwise. It defaults to the
* paramterized type of the collection when defined using
* generics.
*/
Class targetClass() default void.class;
/**
* (Required) The database name of the database array structure type.
*/
String databaseType();
}
Defines the settings and mappings for embeddable objects. Is
allowed to be sparsely populated and used in conjunction with
the annotations. Alternatively, the metadata-complete attribute
can be used to indicate that no annotations are to be processed
in the class. If this is the case then the defaulting rules will
be recursively applied.
@Target({TYPE}) @Retention(RUNTIME)
public @interface Embeddable {}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Embedded {}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface EmbeddedId {}
Defines an entity listener to be invoked at lifecycle events
for the entities that list this listener.
@Target({TYPE}) @Retention(RUNTIME)
public @interface EntityListeners {
Class[] value();
}
@Target({}) @Retention(RUNTIME)
public @interface EntityResult {
Class entityClass();
FieldResult[] fields() default {};
String discriminatorColumn() default "";
}
public enum EnumType {
ORDINAL,
STRING
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Enumerated {
EnumType value() default ORDINAL;
}
@Target({TYPE})
@Retention(RUNTIME)
public @interface FetchAttribute {
/**
* (Required) The fetch attribute name.
*/
String name();
}
@Target({TYPE})
@Retention(RUNTIME)
public @interface FetchGroup {
/**
* (Required) The fetch group name.
*/
String name();
/**
* (Optional) Indicates whether all relationship attributes
* specified in the fetch group should be loaded.
*/
boolean load() default true;
/**
* (Required) The list of attributes to fetch.
*/
FetchAttribute[] attributes();
}
public enum FetchType { LAZY, EAGER };
@Target({}) @Retention(RUNTIME)
public @interface FieldResult {
String name();
String column();
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface GeneratedValue {
GenerationType strategy() default AUTO;
String generator() default "";
}
public enum GenerationType { TABLE, SEQUENCE, IDENTITY, AUTO };
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Id {}
@Target({TYPE}) @Retention(RUNTIME)
public @interface IdClass {
Class value();
}
/**
* The IdValidation enum determines the type value that are valid for an Id.
* By default null is not allowed, and 0 is not allow for singleton ids of long or int type.
* The default value is ZERO for singleton ids, and NULL for composite ids.
* This can be set using the @PrimaryKey annotation, or ClassDescriptor API.
*
* @see PrimaryKey
* @see org.eclipse.persistence.descriptors.ClassDescriptor#setIdValidation(IdValidation)
* @author James Sutherland
* @since EclipseLink 1.0
*/
public enum IdValidation {
/**
* Only null is not allowed as an id value, 0 is allowed.
*/
NULL,
/**
* null and 0 are not allowed, (only int and long).
*/
ZERO,
/**
* No id validation is done.
*/
NONE
}
/**
* Configures what type of Id value is used to store the object in the cache.
* This can either be the basic Id value for simple singleton Ids,
* or an optimized CacheKey type.
*
* @see PrimaryKey#cacheKeyType()
* @see ClassDescriptor#setCacheKeyType(CacheKeyType)
* @author James Sutherland
* @since EclipseLink 2.1
*/
public enum CacheKeyType {
/**
* This can only be used for simple singleton Ids, such as long/int/String.
* This is the default for simple singleton Ids.
*/
ID_VALUE,
/**
* Optimized cache key type that allows composite and complex values.
* This is the default for composite or complex Ids.
*/
CACHE_KEY,
/**
* The cache key type is automatically configured depending on what is optimal for the class.
*/
AUTO
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface Inheritance {
InheritanceType strategy() default SINGLE_TABLE;
}
public enum InheritanceType
{ SINGLE_TABLE, JOINED, TABLE_PER_CLASS};
/**
* An InstantiationCopyPolicy is used to set an
* org.eclipse.persistence.descriptors.copying.InstantiationCopyPolicy
* on an Entity. InstantiationCopyPolicy is the default CopyPolicy in
* EclipseLink and therefore this configuration option is only used to
* override other types of copy policies
*
* An InstantiationCopyPolicy should be specified on an Entity,
* MappedSuperclass or Embeddable.
*
* Example:
* @Entity
* @InstantiationCopyPolicy
*/
public @interface InstantiationCopyPolicy {
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface JoinColumn {
String name() default "";
String referencedColumnName() default "";
boolean unique() default false;
boolean nullable() default true;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
String table() default "";
}
public enum JoinFetchType {
/**
* An inner join is used to fetch the related object.
* This does not allow for null/empty values.
*/
INNER,
/**
* An inner join is used to fetch the related object.
* This allows for null/empty values.
*/
OUTER,
}
public enum BatchFetchType {
/**
* This is the default form of batch reading.
* The original query's selection criteria is joined with the batch query.
*/
JOIN,
/**
* This uses an SQL EXISTS and a sub-select in the batch query instead of a join.
* This has the advantage of not requiring an SQL DISTINCT which can have issues
* with LOBs, or may be more efficient for some types of queries or on some databases.
*/
EXISTS,
/**
* This uses an SQL IN clause in the batch query passing in the source object Ids.
* This has the advantage of only selecting the objects not already contained in the cache,
* and can work better with cursors, or if joins cannot be used.
* This may only work for singleton Ids on some databases.
*/
IN
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface JoinTable {
String name() default "";
String catalog() default "";
String schema() default "";
JoinColumn[] joinColumns() default {};
JoinColumn[] inverseJoinColumns() default {};
UniqueConstraint[] uniqueConstraints() default {};
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Lob {}
public enum LockModeType { READ, WRITE, OPTIMISTIC, OPTIMISTIC_FORCE_INCREMENT, PESSIMISTIC_READ, PESSIMISTIC_WRITE, PESSIMISTIC_FORCE_INCREMENT, NONE};
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface ManyToMany {
Class targetEntity() default void.class;
CascadeType[] cascade() default {};
FetchType fetch() default LAZY;
String mappedBy() default "";
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface ManyToOne {
Class targetEntity() default void.class;
CascadeType[] cascade() default {};
FetchType fetch() default EAGER;
boolean optional() default true;
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface MapKey {
String name() default "";
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface MapKeyClass {
Class value();
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface MapKeyColumn {
String name() default "";
boolean unique() default false;
boolean nullable() default false;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
String table() default "";
int length() default 255;
int precision() default 0; // decimal precision
int scale() default 0; // decimal scale
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface MapKeyJoinColumn {
String name() default "";
String referencedColumnName() default "";
boolean unique() default false;
boolean nullable() default false;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
String table() default "";
}
Defines the settings and mappings for a mapped superclass. Is
allowed to be sparsely populated and used in conjunction with
the annotations. Alternatively, the metadata-complete attribute
can be used to indicate that no annotations are to be processed
If this is the case then the defaulting rules will be recursively
applied.
@Target(TYPE) @Retention(RUNTIME)
public @interface MappedSuperclass{}
@Target({TYPE})
@Retention(RUNTIME)
public @interface Multitenant {
/**
* (Optional) Specify the multi-tenant strategy to use.
*/
MultitenantType value() default MultitenantType.SINGLE_TABLE;
}
public enum MultitenantType {
/**
* Specifies that table(s) the entity maps to includes rows for multiple
* tenants. The tenant discriminator column(s) are used with application
* context values to limit what a persistence context can access.
*/
SINGLE_TABLE,
/**
* Specifies that different tables are used for each tenant. The table scan
* be uniquely identified by name, schema/tablespace.
*/
TABLE_PER_TENANT
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface NamedNativeQuery {
String name();
String query();
QueryHint[] hints() default {};
Class resultClass() default void.class;
String resultSetMapping() default ""; //named SqlResultSetMapping
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface NamedQuery {
String name();
String query();
LockModeType lockMode() default NONE;
QueryHint[] hints() default {};
}
/**
* A NamedStoredProcedureQuery annotation allows the definition of
* queries that call stored procedures as named queries.
* A NamedStoredProcedureQuery annotation may be defined on an Entity or
* MappedSuperclass.
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface NamedStoredProcedureQuery {
/**
* (Required) Unique name that references this stored procedure query.
*/
String name();
/**
* (Optional) Query hints.
*/
QueryHint[] hints() default {};
/**
* (Optional) Refers to the class of the result.
*/
Class resultClass() default void.class;
/**
* (Optional) The name of the SQLResultMapping.
*/
String resultSetMapping() default "";
/**
* (Required) The name of the stored procedure.
*/
String procedureName();
/**
* (Optional) Whether the query should return a result set.
*/
boolean returnsResultSet() default true;
/**
* (Optional) Defines if the stored procedure returns multiple result sets.
* This is only relevant on databases that support multiple result sets from stored procedures.
*/
boolean multipleResultSets() default false;
/**
* (Optional) Defines if the stored procedure should be called by index or by name.
* By index requires that the StoredProcedureParameter are defined in the same order as the procedure on the database.
* By name requires the database platform support naming procedure parameters.
*/
boolean callByIndex() default false;
/**
* (Optional) Defines arguments to the stored procedure.
*/
StoredProcedureParameter[] parameters() default {};
}
/**
* A NamedStoredFunctionQuery annotation allows the definition of
* queries that call stored function as named queries.
* A NamedStoredFunctionQuery annotation may be defined on an Entity or
* MappedSuperclass.
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface NamedStoredFunctionQuery {
/**
* (Required) Unique name that references this stored procedure query.
*/
String name();
/**
* (Optional) Query hints.
*/
QueryHint[] hints() default {};
/**
* (Optional) The name of the SQLResultMapping.
*/
String resultSetMapping() default "";
/**
* (Required) The name of the stored procedure.
*/
String functionName();
/**
* (Optional) Defines if the stored procedure should be called by index or by name.
* By index requires that the StoredProcedureParameter are defined in the same order as the procedure on the database.
* By name requires the database platform support naming procedure parameters.
*/
boolean callByIndex() default false;
/**
* (Optional) Defines arguments to the stored procedure.
*/
StoredProcedureParameter[] parameters() default {};
/**
* (Required) Defines return of the stored function.
*/
StoredProcedureParameter[] returnParameter();
}
/**
* A NamedPLSQLStoredFunctionQuery annotation allows the definition of queries that
* call PLSQL stored functions as named queries.
* The PLSQL support adds support for complex PLSQL types such as RECORD and TABLE types,
* that are not accessible from JDBC.
*
* A NamedPLSQLStoredFunctionQuery annotation may be defined on an Entity or
* MappedSuperclass.
*
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface NamedPLSQLStoredFunctionQuery {
/**
* (Required) Unique name that references this stored procedure query.
*/
String name();
/**
* (Optional) Query hints.
*/
QueryHint[] hints() default {};
/**
* (Optional) The name of the SQLResultMapping.
*/
String resultSetMapping() default "";
/**
* (Required) The name of the stored procedure.
*/
String functionName();
/**
* (Optional) Defines the parameters to the stored procedure.
*/
PLSQLParameter[] parameters() default {};
/**
* (Required) Defines the return value of the stored function.
*/
PLSQLParameter returnParameter();
}
/**
* A PLSQLNamedStoredProcedureQuery annotation allows the definition of queries that
* call PLSQL stored procedures as named queries.
* The PLSQL support adds support for complex PLSQL types such as RECORD and TABLE types,
* that are not accessible from JDBC.
*
* A PLSQLNamedStoredProcedureQuery annotation may be defined on an Entity or
* MappedSuperclass.
*
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface NamedPLSQLStoredProcedureQuery {
/**
* (Required) Unique name that references this stored procedure query.
*/
String name();
/**
* (Optional) Query hints.
*/
QueryHint[] hints() default {};
/**
* (Optional) Refers to the class of the result.
*/
Class resultClass() default void.class;
/**
* (Optional) The name of the SQLResultMapping.
*/
String resultSetMapping() default "";
/**
* (Required) The name of the stored procedure.
*/
String procedureName();
/**
* (Optional) Defines the parameters to the stored procedure.
*/
PLSQLParameter[] parameters() default {};
}
/**
* A PLSQLRecord annotation is used to define a database PLSQL RECORD type.
* This type can be used within PLSQL procedure calls.
*
* @see NamedPLSQLStoredProcedureQuery
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface PLSQLRecord {
/**
* (Required) The name of the record type in the database.
*/
String name();
/**
* (Required) The name of the database OBJECT TYPE that mirrors the record's structure.
* The record will be converted to/from this type so it can be passed through JDBC.
*/
String compatibleType();
/**
* (Optional) The Java class to map the object-type to.
* This class must be mapped using a @Struct annotation.
*/
Class javaType() default void.class;
/**
* (Required) Defines the fields in the record type.
*/
PLSQLParameter[] fields();
}
/**
* A PLSQLRecord annotation is used to define a database PLSQL RECORD type.
* This type can be used within PLSQL procedure calls.
*
* @see NamedPLSQLStoredProcedureQuery
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface PLSQLRecord {
/**
* (Required) The name of the record type in the database.
*/
String name();
/**
* (Required) The name of the database OBJECT TYPE that mirrors the record's structure.
* The record will be converted to/from this type so it can be passed through JDBC.
*/
String compatibleType();
/**
* (Optional) The Java class to map the object-type to.
* This class must be mapped using a @Struct annotation.
*/
Class javaType() default void.class;
/**
* (Required) Defines the fields in the record type.
*/
PLSQLParameter[] fields();
}
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface ObjectTypeConverter {
/**
* (Required) Name this converter. The name should be unique
* across the whole persistence unit.
*/
String name();
/**
* (Optional) Specify the type stored on the database. The
* default is inferred from the type of the persistence
* field or property.
*/
Class dataType() default void.class;
/**
* (Optional) Specify the type stored on the entity. The
* default is inferred from the type of the persistent
* field or property.
*/
Class objectType() default void.class;
/**
* (Required) Specify the conversion values to be used
* with the object converter.
*/
ConversionValue[] conversionValues();
/**
* (Optional) Specify a default object value. Used for
* legacy data if the data value is missing.
*/
String defaultObjectValue() default "";
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface OneToMany {
Class targetEntity() default void.class;
CascadeType[] cascade() default {};
FetchType fetch() default LAZY;
String mappedBy() default "";
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface OneToOne {
Class targetEntity() default void.class;
CascadeType[] cascade() default {};
FetchType fetch() default EAGER;
boolean optional() default true;
String mappedBy() default "";
boolean orphanRemoval() default false;
}
/**
* An optimistic-locking element is used to specify the type of
* optimistic locking EclipseLink should use when updating or deleting
* entities. An optimistic-locking specification is supported on
* an entity or mapped-superclass.
*
* It is used in conjunction with the optimistic-locking-type.
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface OptimisticLocking {
/**
* (Optional) The type of optimistic locking policy to use.
*/
OptimisticLockingType type() default VERSION_COLUMN;
/**
* (Optional) For an optimistic locking policy of type
* SELECTED_COLUMNS, this annotation member becomes a (Required)
* field.
*/
Column[] selectedColumns() default {};
/**
* (Optional) Specify where the optimistic locking policy should
* cascade lock. Currently only supported with VERSION_COLUMN locking.
*/
boolean cascade() default false;
}
/**
* A simple type that is used within an optimistic-locking
* specification to specify the type of optimistic-locking that
* EclipseLink should use when updating or deleting entities.
*/
public enum OptimisticLockingType {
/**
* Using this type of locking policy compares every field in the table
* in the WHERE clause when doing an update or a delete. If any field
* has been changed, an optimistic locking exception will be thrown.
*/
ALL_COLUMNS,
/**
* Using this type of locking policy compares only the changed fields
* in the WHERE clause when doing an update. If any field has been
* changed, an optimistic locking exception will be thrown. A delete
* will only compare the primary key.
*/
CHANGED_COLUMNS,
/**
* Using this type of locking compares selected fields in the WHERE
* clause when doing an update or a delete. If any field has been
* changed, an optimistic locking exception will be thrown. Note that
* the fields specified must be mapped and not be primary keys.
*/
SELECTED_COLUMNS,
/**
* Using this type of locking policy compares a single version number
* in the where clause when doing an update. The version field must be
* mapped and not be the primary key.
*/
VERSION_COLUMN
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface OrderBy {
String value() default "";
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface OrderColumn {
String name() default "";
boolean nullable() default true;
boolean insertable() default true;
boolean updatable() default true;
String columnDefinition() default "";
}
public enum OrderCorrectionType {
READ,
READ_WRITE,
EXCEPTION
}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PostLoad {}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PostPersist {}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PostRemove {}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PostUpdate {}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PrePersist {}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PreRemove {}
@Target({METHOD}) @Retention(RUNTIME)
public @interface PreUpdate {}
/**
* The PrimaryKey annotation allows advanced configuration of the Id.
* A validation policy can be given that allows specifying if zero is a valid id value.
* The set of primary key columns can also be specified precisely.
*
* @author James Sutherland
* @since EclipseLink 1.1
*/
@Target({TYPE})
@Retention(RUNTIME)
public @interface PrimaryKey {
/**
* (Optional) Configures what id validation is done.
* By default 0 is not a valid id value, this can be used to allow 0 id values.
*/
IdValidation validation() default IdValidation.ZERO;
/**
* (Optional) Configures what cache key type is used to store the object in the cache.
* By default the type is determined by what type is optimal for the class.
*/
CacheKeyType cacheKeyType() default CacheKeyType.AUTO;
/**
* (Optional) Used to specify the primary key columns directly.
* This can be used instead of @Id if the primary key includes a non basic field,
* such as a foreign key, or a inheritance discriminator, embedded, or transformation mapped field.
*/
Column[] columns() default {};
}
@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)
public @interface PrimaryKeyJoinColumn {
String name() default "";
String referencedColumnName() default "";
String columnDefinition() default "";
}
A user defined mapping's property.
@Target({METHOD, FIELD, TYPE})
@Retention(RUNTIME)
public @interface Property {
/**
* Property name.
*/
String name();
/**
* String representation of Property value,
* converted to an instance of valueType.
*/
String value();
/**
* Property value type.
* The value converted to valueType by ConversionManager.
* If specified must be a simple type that could be handled by
* ConversionManager:
* numerical, boolean, temporal.
*/
Class valueType() default String.class;
}
@Target({}) @Retention(RUNTIME)
public @interface QueryHint {
String name();
String value();
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface QueryRedirectors {
/**
* This AllQueries Query Redirector will be applied to any executing object query
* that does not have a more precise redirector (like the
* ReadObjectQuery Redirector) or a redirector set directly on the query.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
*
*/
Class allQueries() default void.class;
/**
* A Default ReadAll Query Redirector will be applied to any executing
* ReadAllQuery that does not have a redirector set directly on the query.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
* For users executing a JPA Query through the getResultList() API this is the redirector that will be invoked
*/
Class readAll() default void.class;
/**
* A Default ReadObject Query Redirector will be applied to any executing
* ReadObjectQuery that does not have a redirector set directly on the query.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
* For users executing a JPA Query through the getSingleResult() API or EntityManager.find() this is the redirector that will be invoked
*/
Class readObject() default void.class;
/**
* A Default ReportQuery Redirector will be applied to any executing
* ReportQuery that does not have a redirector set directly on the query.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
* For users executing a JPA Query that contains agregate functions or selects multiple entities this is the redirector that will be invoked
*/
Class report() default void.class;
/**
* A Default Update Query Redirector will be applied to any executing
* UpdateObjectQuery or UpdateAllQuery that does not have a redirector set directly on the query.
* In EclipseLink an UpdateObjectQuery is executed whenever flushing changes to the datasource.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
*/
Class update() default void.class;
/**
* A Default Insert Query Redirector will be applied to any executing
* InsertObjectQuery that does not have a redirector set directly on the query.
* In EclipseLink an InsertObjectQuery is executed when persisting an object to the datasource.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
*/
Class insert() default void.class;
/**
* A Default Delete Object Query Redirector will be applied to any executing
* DeleteObjectQuery or DeleteAllQuery that does not have a redirector set directly on the query.
* Query redirectors allow the user to intercept query execution preventing
* it or alternately performing some side effect like auditing.
*/
Class delete() default void.class;
}
/**
* Annotation for org.eclipse.persistence.mappings.TransformationMapping.
* Unless the TransformationMapping is write-only, it should have a
* ReadTransformer, it defines transformation of database column(s)
* value(s)into attribute value.
*
* Also unless it's a read-only mapping, either WriteTransformer
* annotation or WriteTransformers annotation should be specified. Each
* WriteTransformer defines transformation of the attribute value to a
* single database column value (column is specified in the
* WriteTransformer).
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface ReadTransformer {
/**
* User-defined class that must implement the
* org.eclipse.persistence.mappings.transformers.AttributeTransformer
* interface. The class will be instantiated, its
* buildAttributeValue will be used to create the value to be
* assigned to the attribute.
* Either transformerClass or method must be specified, but not both.
*/
Class transformerClass() default void.class;
/**
* The mapped class must have a method with this name which returns
* a value to be assigned to the attribute (not assigns the value to
* the attribute). Either transformerClass or method must be
* specified, but not both.
*/
String method() default "";
}
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface ReturnInsert {
/**
* A ReturnInsert annotation allows for INSERT operations to return
* values back into the object being written. This allows for table
* default values, trigger or stored procedures computed values to
* be set back into the object.
*/
boolean returnOnly() default false;
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface SecondaryTable {
String name();
String catalog() default "";
String schema() default "";
PrimaryKeyJoinColumn[] pkJoinColumns() default {};
UniqueConstraint[] uniqueConstraints() default {};
}
@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)
public @interface SequenceGenerator {
String name();
String sequenceName() default "";
String catalog() default "";
String schema() default "";
int initialValue() default 1;
int allocationSize() default 50;
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface SqlResultSetMapping {
String name();
EntityResult[] entities() default {};
ColumnResult[] columns() default {};
}
/**
* A StoredProcedureParameter annotation is used within a
* NamedStoredProcedureQuery annotation.
*/
@Target({})
@Retention(RUNTIME)
public @interface StoredProcedureParameter {
/**
* (Optional) The direction of the stored procedure parameter.
*/
Direction direction() default IN;
/**
* (Optional) Stored procedure parameter name.
*/
String name() default "";
/**
* (Required) The query parameter name.
*/
String queryParameter();
/**
* (Optional) Define if the parameter is required, or optional and defaulted by the procedure.
*/
boolean optional() default false;
/**
* (Optional) The type of Java class desired back from the procedure,
* this is dependent on the type returned from the procedure.
*/
Class type() default void.class;
/**
* (Optional) The JDBC type code, this dependent on the type returned
* from the procedure.
*/
int jdbcType() default -1;
/**
* (Optional) The JDBC type name, this may be required for ARRAY or
* STRUCT types.
*/
String jdbcTypeName() default "";
}
/**
* A PLSQLParameter annotation is used within a
* NamedPLSQLStoredProcedureQuery or PLSQLRecord annotation.
*
* @see NamedPLSQLStoredProcedureQuery
* @see PLSQLRecord
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({})
@Retention(RUNTIME)
public @interface PLSQLParameter {
/**
* (Optional) The direction of the stored procedure parameter.
*/
Direction direction() default IN;
/**
* (Required) Stored procedure parameter name.
*/
String name() default "";
/**
* (Optional) The query parameter name.
*/
String queryParameter();
/**
* (Optional) Define if the parameter is required, or optional and defaulted by the procedure.
*/
boolean optional() default false;
/**
* (Optional) The database data-type for the paramter.
* This either one of the type constants defined in OraclePLSQLTypes, or JDBCTypes,
* or a custom record or table type name.
* @see PLSQLRecord
* @see OraclePLSQLTypes
* @see JDBCTypes
*/
String databaseType() default "VARCHAR";
/**
* (Optional) The max length of the field value.
*/
int length() default 255;
/**
* (Optional) If a numeric, the max scale value.
*/
int scale() default 0;
/**
* (Optional) If a numeric, the max precision value.
*/
int precision() default 0;
}
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface StructConverter {
/**
* (Required) Name this converter. The name should be unique across
* the whole persistence unit.
*/
String name();
/**
* (Required) The converter class to be used. This class must
* implement the EclipseLink interface
* org.eclipse.persistence.mappings.converters.Converter
*/
String converter();
}
/**
* Struct types are extended object-relational data-types supported by some databases.
* Struct types are user define types in the database such as OBJECT types on Oracle.
* Structs can normally contains Arrays (VARRAY) or other Struct types, and can be stored in
* a column or a table.
* This annotation define a class to map to a database Struct type.
* The class should normally be an Embeddable, but could also be an Entity if stored in a object table.
*
* @see org.eclipse.persistence.mappings.structures.ObjectRelationalDataTypeDescriptor
* @see org.eclipse.persistence.mappings.structures.StructureMapping
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface Struct {
/**
* (Required) The database name of the database structure type.
*/
String name();
/**
* (Optional) Defines the order of the fields contained in the database structure type.
*/
String[] fields() default {};
}
/**
* Struct types are extended object-relational data-types supported by some databases.
* Struct types are user define types in the database such as OBJECT types on Oracle.
* Structs can normally contains Arrays (VARRAY) or other Struct types, and can be stored in
* a column or a table.
* This annotation can be defined on a field/method to define an StructureMapping to an embedded Struct type.
* The target Embeddable must be mapped using the Struct annotation.
*
* @see Struct
* @see org.eclipse.persistence.mappings.structures.ObjectRelationalDataTypeDescriptor
* @see org.eclipse.persistence.mappings.structures.StructureMapping
* @author James Sutherland
* @since EclipseLink 2.3
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Structure {
}
@Target({TYPE}) @Retention(RUNTIME)
public @interface Table {
String name() default "";
String catalog() default "";
String schema() default "";
UniqueConstraint[] uniqueConstraints() default {};
}
/**
* Allow a database INDEX to be define when generating DDL.
* The @Index can be defined on a Entity class, or on an attribute.
* The column is defaulted when defined on a attribute.
*
* @author James Sutherland
* @since EclipseLink 2.2
*/
@Target({METHOD, FIELD, TYPE})
@Retention(RUNTIME)
public @interface Index {
/** The name of the INDEX, defaults to INDEX_(table-name) */
String name() default "";
/** The schema of the INDEX */
String schema() default "";
/** The catalog of the INDEX */
String catalog() default "";
/** The table to define the index on, defaults to entities primary table. */
String table() default "";
boolean unique() default false;
/**
* Specify the set of columns to define the index on.
* Not required when annotated on a field/method.
*/
String[] columnNames() default {};
}
@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME)
public @interface TableGenerator {
String name();
String table() default "";
String catalog() default "";
String schema() default "";
String pkColumnName() default "";
String valueColumnName() default "";
String pkColumnValue() default "";
int initialValue() default 0;
int allocationSize() default 50;
UniqueConstraint[] uniqueConstraints() default {};
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Temporal {
TemporalType value();
}
public enum TemporalType {
DATE, // java.sql.Date
TIME, // java.sql.Time
TIMESTAMP // java.sql.Timestamp
}
@Target({})
@Retention(RUNTIME)
public @interface TenantDiscriminator {
/**
* (Optional) The name of column to be used for the discriminator.
*/
String name() default "eclipselink.tenant-id";
/**
* (Optional) The name of the context property to apply to the
* tenant discriminator column.
*/
String contextProperty() default "TENANT_ID";
/**
* (Optional) The type of object/column to use as a class discriminator.
* Defaults to {@link DiscriminatorType#STRING DiscriminatorType.STRING}.
*/
DiscriminatorType discriminatorType() default DiscriminatorType.STRING;
/**
* (Optional) The SQL fragment that is used when generating the DDL
* for the discriminator column.
* Defaults to the provider-generated SQL to create a column
* of the specified discriminator type.
*/
String columnDefinition() default "";
/**
* (Optional) The column length for String-based discriminator types.
* Ignored for other discriminator types.
*/
int length() default 31;
/**
* (Optional) The name of the table that contains the column.
* If absent the column is assumed to be in the primary table.
*/
String table() default "";
/**
* Specifies that the tenant discriminator column is part of the primary
* key of the tables.
*/
boolean primaryKey() default false;
}
@Target({})
@Retention(RUNTIME)
public @interface TimeOfDay {
/**
* (Optional) Hour of the day.
*/
int hour() default 0;
/**
* (Optional) Minute of the day.
*/
int minute() default 0;
/**
* (Optional) Second of the day.
*/
int second() default 0;
/**
* (Optional) Millisecond of the day.
*/
int millisecond() default 0;
/**
* Internal use. Do not modify.
*/
boolean specified() default true;
}
/**
* Transformation is an optional annotation for
* org.eclipse.persistence.mappings.TransformationMapping.
* TransformationMapping allows to map an attribute to one or more
* database columns.
*
* Transformation annotation is an optional part of
* TransformationMapping definition. Unless the TransformationMapping is
* write-only, it should have a ReadTransformer, it defines
* transformation of database column(s) value(s)into attribute value.
* Also unless it's a read-only mapping, either WriteTransformer
* annotation or WriteTransformers annotation should be specified. Each
* WriteTransformer defines transformation of the attribute value to a
* single database column value (column is specified in the
* WriteTransformer).
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Transformation {
/**
* (Optional) Defines whether the value of the field or property
* should be lazily loaded or must be eagerly fetched. The EAGER
* strategy is a requirement on the persistence provider runtime
* that the value must be eagerly fetched. The LAZY strategy is a
* hint to the persistence provider runtime. If not specified,
* defaults to EAGER.
*/
FetchType fetch() default EAGER;
/**
* (Optional) The optional element is a hint as to whether the value
* of the field or property may be null. It is disregarded
* for primitive types, which are considered non-optional.
*/
boolean optional() default true;
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Transient {}
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface TypeConverter {
/**
* (Required) Name this converter. The name should be unique
* across the whole persistence unit.
*/
String name();
/**
* (Optional) Specify the type stored on the database. The
* default is inferred from the type of the persistence field
* or property.
*/
Class dataType() default void.class;
/**
* (Optional) Specify the type stored on the entity. The
* default is inferred from the type of the persistent field
* or property.
*/
Class objectType() default void.class;
}
@Target({}) @Retention(RUNTIME)
public @interface UniqueConstraint {
String name() default "";
String[] columnNames();
}
/**
* Variable one to one mappings are used to represent a pointer
* references between a java object and an implementer of an interface.
* This mapping is usually represented by a single pointer (stored in an
* instance variable) between the source and target objects. In the
* relational database tables, these mappings are normally implemented
* using a foreign key and a type code.
*
* A VariableOneToOne can be specified within an Entity,
* MappedSuperclass and Embeddable class.
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface VariableOneToOne {
/**
* (Optional) The interface class that is the target of the
* association. If not specified it will be inferred from the type
* of the object being referenced.
*/
Class targetInterface() default void.class;
/**
* (Optional) The operations that must be cascaded to the target of
* the association.
*/
CascadeType[] cascade() default {};
/**
* (Optional) Defines whether the value of the field or property
* should be lazily loaded or must be eagerly fetched. The EAGER
* strategy is a requirement on the persistence provider runtime
* that the value must be eagerly fetched. The LAZY strategy is a
* hint to the persistence provider runtime. If not specified,
* defaults to EAGER.
*/
FetchType fetch() default EAGER;
/**
* (Optional) Whether the association is optional. If set to false
* then a non-null relationship must always exist.
*/
boolean optional() default true;
/**
* (Optional) The discriminator column will hold the type
* indicators. If the DiscriminatorColumn is not specified, the name
* of the discriminator column defaults to "DTYPE" and the
* discriminator type to STRING.
*/
DiscriminatorColumn discriminatorColumn() default @DiscriminatorColumn;
/**
* (Optional) The list of discriminator types that can be used with
* this VariableOneToOne. If none are specified then those entities
* within the persistence unit that implement the target interface
* will be added to the list of types. The discriminator type will
* default as follows:
* - If DiscriminatorColumn type is STRING: Entity.name()
* - If DiscriminatorColumn type is CHAR: First letter of the
* Entity class
* - If DiscriminatorColumn type is INTEGER: The next integer after
* the highest integer explicitly added.
*/
DiscriminatorClass[] discriminatorClasses() default {};
}
@Target({METHOD, FIELD}) @Retention(RUNTIME)
public @interface Version {}
/**
* Annotation for org.eclipse.persistence.mappings.TransformationMapping.
* WriteTransformer defines transformation of the attribute value to a
* single database column value (column is specified in the
* WriteTransformer).
*
* A single WriteTransformer may be specified directly on the method or
* attribute. Multiple WriteTransformers should be wrapped into
* WriteTransformers annotation. No WriteTransformers specified for
* read-only mapping. Unless the TransformationMapping is write-only, it
* should have a ReadTransformer, it defines transformation of database
* column(s) value(s)into attribute value.
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface WriteTransformer {
/**
* User-defined class that must implement the
* org.eclipse.persistence.mappings.transformers.FieldTransformer
* interface. The class will be instantiated, its buildFieldValue
* will be used to create the value to be written into the database
* column. Note that for ddl generation and returning to be
* supported the method buildFieldValue in the class should be
* defined to return the relevant Java type, not just Object as
* defined in the interface, for instance:
* public Time buildFieldValue(Object instance, String fieldName, Session session).
* Either transformerClass or method must be specified, but not both.
*/
Class transformerClass() default void.class;
/**
* The mapped class must have a method with this name which returns
* a value to be written into the database column.
* Note that for ddl generation and returning to be supported the
* method should be defined to return a particular type, not just
* Object, for instance:
* public Time getStartTime().
* The method may require a Transient annotation to avoid being
* mapped as Basic by default.
* Either transformerClass or method must be specified, but not both.
*/
String method() default "";
/**
* Specify here the column into which the value should be written.
* The only case when this could be skipped is if a single
* WriteTransformer annotates an attribute - the attribute's name
* will be used as a column name.
*/
Column column() default @Column;
}
/**
* A BatchFetch annotation can be used on any relationship mapping,
* (OneToOne, ManyToOne, OneToMany, ManyToMany, ElementCollection, BasicCollection, BasicMap).
* It allows the related objects to be batch read in a single query.
* Batch fetching can also be set at the query level, and it is
* normally recommended to do so as all queries may not require batching.
*
* @author James Sutherland
* @since EclipseLink 2.1
*/
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface BatchFetch {
/**
* (Optional) The type of batch-fetch to use.
* Either JOIN, EXISTS or IN.
* JOIN is the default.
*/
BatchFetchType value() default BatchFetchType.JOIN;
/**
* Define the default batch fetch size.
* This is only used for IN type batch reading and defines
* the number of keys used in each IN clause.
* The default size is 256, or the query's pageSize for cursor queries.
*/
int size() default -1;
}