From b99e47e6f31194535cec93cc348f3f41118a89e4 Mon Sep 17 00:00:00 2001
From: pfullbright
Date: Mon, 9 May 2011 15:27:28 +0000
Subject: added EclipseLink 2.3 JPA platform and UI
---
.../schemas/eclipselink_orm_2_3.xsd | 5464 ++++++++++++++++++++
.../schemas/eclipselink_oxm_2_3.xsd | 573 ++
.../schemas/eclipselink_persistence_map_2.3.xsd | 4302 +++++++++++++++
3 files changed, 10339 insertions(+)
create mode 100644 common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_orm_2_3.xsd
create mode 100644 common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_oxm_2_3.xsd
create mode 100644 common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_persistence_map_2.3.xsd
(limited to 'common/plugins')
diff --git a/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_orm_2_3.xsd b/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_orm_2_3.xsd
new file mode 100644
index 0000000000..4afc815ece
--- /dev/null
+++ b/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_orm_2_3.xsd
@@ -0,0 +1,5464 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @(#)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;
+ }
+
+
+
+
+
+
+
+
+
diff --git a/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_oxm_2_3.xsd b/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_oxm_2_3.xsd
new file mode 100644
index 0000000000..8206454e5e
--- /dev/null
+++ b/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_oxm_2_3.xsd
@@ -0,0 +1,573 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_persistence_map_2.3.xsd b/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_persistence_map_2.3.xsd
new file mode 100644
index 0000000000..69a39f0f74
--- /dev/null
+++ b/common/plugins/org.eclipse.jpt.common.eclipselink.core/schemas/eclipselink_persistence_map_2.3.xsd
@@ -0,0 +1,4302 @@
+
+
+
+
+
+
+
+ An object-persistence mapping module, a set of class-mapping-descriptors.
+
+
+
+
+ A name for the model being mapped.
+
+
+
+
+ The list of class mapping descriptors.
+
+
+
+
+
+ Information of how a class is persisted to its data-store.
+
+
+
+
+
+
+
+ The datasource connection and configuration information.
+
+
+
+
+ Defines the default for how Date and Calendar types are used with change tracking.
+ By default they are assumed not to be changed directly (only replaced).
+
+
+
+
+ A list of queries to be stored on the session.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The datasource connection and configuration information.
+
+
+
+
+ The fully qualified name of the platform class.
+
+
+
+
+ The datasource user-name.
+
+
+
+
+ The datasource password, this is stored in encrypted form.
+
+
+
+
+ Defines if the connections are managed by the datasource driver, and a new connection should be acquire per call.
+
+
+
+
+ Defines if the transaction are managed by a transaction manager, and should not be managed by TopLink.
+ This can also be used if the datasource does not support transactions.
+
+
+
+
+ Sequencing information.
+
+
+
+
+
+ Default sequence. The name is optional. If no name provided an empty string will be used as a name.
+
+
+
+
+ Non default sequences. Make sure each sequence has unique name.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The JDBC driver and database connection and configuration information.
+
+
+
+
+
+
+ The fully qualified name of the JDBC driver class.
+
+
+
+
+ The full JDBC driver connection URL.
+
+
+
+
+ Configure if parameter binding should be used.
+
+
+
+
+ Configure if statement caching should be used. This should be used with parameter binding, this cannot be used with external connection pooling.
+
+
+
+
+ Configure if byte array data-types should use binding.
+
+
+
+
+ Configure if string data-types should use binding.
+
+
+
+
+ Configure the threshold string size for usage of string binding.
+
+
+
+
+ Configure if large byte array and string data-types should be bound as streams.
+
+
+
+
+ Configure to force all field names to upper-case.
+
+
+
+
+ Configure data optimization.
+
+
+
+
+ Configure if string trailing blanks should be trimmed. This is normally required for CHAR data-types.
+
+
+
+
+ Configure if batch writing should be used.
+
+
+
+
+ If using batch writing, configure if the JDBC drivers batch writing should be used.
+
+
+
+
+
+
+
+
+ The JCA driver and EIS connection and configuration information.
+
+
+
+
+
+
+ The fully qualified name of the TopLink platform specific connection spec class.
+
+
+
+
+ The JNDI url for the managed JCA adapter's connection factory.
+
+
+
+
+
+
+
+
+ The connection and configuration information.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Information of how a class is persisted to its data-store.
+ This is an abstract definition to allow flexibility in the types of classes and datastores persisted, i.e. interfaces, abstract classes, aggregates, non-relational persistence.
+
+
+
+
+ The name of the implementation class being persisted. The class name must be full qualified with its package.
+ Example: example.employee.implementation.Employee
+
+
+
+
+ Optionally an alias name can be given for the class. The alias is a string that can be used to refer to the class in place of its implementation name, such as in querying.
+ Example: Employee
+
+
+
+
+ The list of fields/columns that make up the primary key or unique identifier of the class.
+ This is used for caching, relationships, and for database operations.
+
+
+
+
+
+ The primary key field.
+
+
+
+
+
+
+
+ Defines if the class is read-only.
+
+
+
+
+ Allow for user defined properties to be defined.
+
+
+
+
+
+ A user defined property.
+
+
+
+
+
+
+
+ Defines how the class is related in inheritance and how this inheritance is persisted.
+
+
+
+
+ Defines the persistent events for this class.
+
+
+
+
+ The list of defined queries for the class.
+
+
+
+
+ The list of mappings that define how the class' attributes are persisted.
+
+
+
+
+
+ Defines how a attribute is persisted. The attribute mapping definition is extendable to allow for different types of mappings.
+
+
+
+
+
+
+
+ Defines the descriptor type, such as aggregate or independent.
+
+
+
+
+ Defines the interfaces that this class implements..
+
+
+
+
+ Defines the locking behavior for the class. Such as an optimistic locking policy based on version, timestamp or change set of columns.
+
+
+
+
+ Defines how a generated unique id should be assigned to the class.
+
+
+
+
+ Defines how the class' instances should be cached.
+
+
+
+
+ Defines how the class' instances should be cached on remote clients.
+
+
+
+
+ Defines how past versions of objects are persisted to the data-store. By default there will be no history policy.
+
+
+
+
+ Defines retuning policy. By default there will be no returning policy.
+
+
+
+
+ Allow for the descriptor to be amended or customized through a class API after loading.
+
+
+
+
+ Allow the object instantiation behavoir to be customized
+
+
+
+
+ Allow the object cloning/copying behavoir to be customized.
+
+
+
+
+ A list of query keys or aliases for database information. These can be used in queries instead of the database column names.
+
+
+
+
+
+ Defines an alias for querying database information.
+
+
+
+
+
+
+
+ Place holder of CMP information specific.
+
+
+
+
+ Contains all pre-defined fetch groups at the descriptor level
+
+
+
+
+ Contains the Change Policy for this descriptor
+
+
+
+
+
+
+
+
+ Defines the class descriptor type.
+
+
+
+
+
+
+
+
+
+
+
+
+ Specify the interfaces that a class descriptor implements, or the implemention class for an interface descriptor.
+ Optionally a set of public interfaces for the class can be specified. This allows the interface to be used to refer to the implementation class.
+ If two classes implement the same interface, an interface descriptor should be defined for the interface.
+ This can also be used to define inheritance between interface descriptors.
+
+
+
+
+ The fully qualified interface class name.
+ Example: example.employee.api.Employee
+
+
+
+
+ The fully qualified class name of the implementation class for which this interface is the public interface.
+ This can be used if the interface has only a single implementor.
+ Example: example.employee.impl.Employee
+
+
+
+
+
+
+ Allow the object cloning/copying behavoir to be customized.
+
+
+
+
+ Creates a copying through creating a new instance to copy into.
+
+
+
+
+
+
+
+ Allow the object cloning/copying behavoir to be customized through a clone method.
+
+
+
+
+
+
+ The name of the clone method on the object, i.e. 'clone'
+
+
+
+
+
+
+
+
+ Allow the object instantiation behavoir to be customized.
+
+
+
+
+ The name of the method on the factory to instantiate the object instance.'
+
+
+
+
+ The fully qualified factory class name.'
+
+
+
+
+ The name of the method to instantiate the factory class.'
+
+
+
+
+
+
+ Specifies a class and static method to be called to allow for the descriptor to be amended or customized through a class API after loading.
+
+
+
+
+ The fully qualified name of the amendment class.
+
+
+
+
+ The name of the static amendment method on the class.
+
+
+
+
+
+
+ Defines a class mapping to a relational database table(s).
+
+
+
+
+
+
+ The list of the tables the class is persisted to. Typically a class is persisted to a single table, but multiple tables can be defined.
+
+
+
+
+
+ The list of tables that the class is persisted to. This is typically a single table but can be multiple, or empty for inheritance or aggregated classes.
+
+
+
+
+
+
+
+ Allow the foreign key field references to be define for multiple table descriptors.
+
+
+
+
+ For complex multiple table join conditions an expression may be provided instead of the table foreign key information.
+
+
+
+
+
+
+
+
+ Defines an optimistic locking policy.
+
+
+
+
+ Defines an optimistic locking policy based on a numeric version field/column that tracks changes and the version to an object.
+
+
+
+
+
+
+ The name and optionally the table of the column that the attribute is stored into.
+
+
+
+
+ Specify if the version value should be stored in the cache, or if it will be stored in the object.
+
+
+
+
+
+
+
+
+ Defines an optimistic locking policy based on timestamp version column that tracks changes and the version to an object.
+
+
+
+
+
+
+ Specify if the timestamp should be obtained locally or from the database server.
+
+
+
+
+
+
+
+
+ Defines an optimistic locking policy based on comparing the original read values of all fields of the object with the current state of the values in the database.
+
+
+
+
+
+
+
+ Defines an optimistic locking policy based on comparing the original read values of only the changed fields of the object with the current state of the values in the database.
+
+
+
+
+
+
+
+ Defines an optimistic locking policy based on comparing the original read values of a specified set of fields of the object with the current state of the values in the database.
+
+
+
+
+
+
+ Specify the set of fields to compare on update and delete.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines how a database generated unique id should be assigned to the class.
+
+
+
+
+ Specify the name of the sequence generator. This could be the name of a sequence object, or a row value in a sequence table.
+
+
+
+
+ Specify the field/column that the generated sequence id is assigned to.
+
+
+
+
+
+
+ Defines the set of valid caching types.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines how the class' instances should be cached and how object identity should be maintained.
+
+
+
+
+ Specify the type of caching, such as LRU, weak reference or none.
+
+
+
+
+ Specify the initial or maximum size of the cache.
+
+
+
+
+ Specify to always refresh cached objects on queries.
+
+
+
+
+ Specify to refresh if the cached object is an older version.
+
+
+
+
+ Disable obtaining cache hits on primary key queries.
+
+
+
+
+ Specify to always conform queries within a transaction.
+
+
+
+
+ Specify if objects of this type should be isolated from the shared cache.
+
+
+
+
+ Specify how the unit of work should be isolated to the session cache.
+
+
+
+
+ Defines the cache invalidation policy. By default there will be no cache invalidation policy.
+
+
+
+
+ The type of cache synchronization to be used with this descripor.
+
+
+
+
+
+
+ Abstract superclass for cache invalidation policies.
+
+
+
+
+
+
+
+ Cache invalidation policy where objects in the cache do not expire.
+
+
+
+
+
+
+
+ Cache invalidation policy where objects live a specific number of milliseconds after they are read.
+
+
+
+
+
+
+
+
+
+
+
+ Cache invalidation Policy where objects expire at a specific time every day
+
+
+
+
+
+
+
+
+
+
+
+ Defines how past versions of objects are to be persisted to the data-store.
+
+
+
+
+
+
+ Defines the names of the mirroring historical tables.
+
+
+
+
+
+
+
+
+
+ Defines the start fields for each historical table.
+
+
+
+
+
+
+
+
+
+ Defines the end fields for each historical table.
+
+
+
+
+
+
+
+
+
+
+
+ Each entry is a source (descriptor) to history table name association.
+
+
+
+
+
+
+
+
+ Defines retuning policy. By default there will be no returning policy.
+
+
+
+
+ Lists the fields to be returned together with the flags defining returning options
+
+
+
+
+
+
+
+
+
+
+
+ Field to be returned together with type and the flags defining returning options. At least one of insert, update should be true.
+
+
+
+
+ The fully qualified name of the target referenced class.
+
+
+
+
+ The field to be returned.
+
+
+
+
+ Indicates whether the field should be retuned after Insert.
+
+
+
+
+ If insert==true, indicates whether the field should not be inserted (true). If insert==false - ignored.
+
+
+
+
+ Indicates whether the field should be retuned after Insert.
+
+
+
+
+
+
+ Defines how the class is related in inheritance and how this inheritance is persisted.
+
+
+
+
+ The name of the parent/superclass of the class being persisted. The class name must be full qualified with its package.
+
+
+
+
+ Define if subclasses of the class should be returned on queries, or only the exact class.
+
+
+
+
+ Optionally specify the name of a view that joins all of the subclass' tables.
+
+
+
+
+ Specifies if the fully qualified class name should be used as the class type indicator.
+
+
+
+
+ The name of a method on the class that takes the class' row as argument a computed that class type to be used to instantiate from the row.
+
+
+
+
+ The name of the type field/column that the class type is stored into.
+
+
+
+
+ The set of class indicator values and the subclasses they map to.
+
+
+
+
+ The name of a class that implements a class extractor interface.
+
+
+
+
+ The criteria that filters out all sibling and subclass instances on queries.
+
+
+
+
+ The criteria that filters out sibling instances on queries.
+
+
+
+
+ For inheritance queries specify if all subclasses should be outer joined, instead of a query per subclass.
+
+
+
+
+
+
+ Extends inheritance policy. Allows for prefixed names to be resolved at runtime to find the approriate class
+
+
+
+
+
+
+
+ The set of class indicator values and the subclasses they map to.
+
+
+
+
+
+
+
+ The fully qualified name of the class the type maps to.
+
+
+
+
+ The field value used to define the class type.
+
+
+
+
+
+
+
+
+
+ Defines the persistent events for this class.
+
+
+
+
+
+
+
+ The fully qualified name of an event listener class that implements the descriptor event listener interface.
+
+
+
+
+
+
+
+ Method executed after building the object.
+
+
+
+
+ Method executed before writing the object.
+
+
+
+
+ Method executed after writing the object.
+
+
+
+
+ Method executed before inserting the object.
+
+
+
+
+ Method executed after inserting the object.
+
+
+
+
+ Method executed before updating the object.
+
+
+
+
+ Method executed after updating the object.
+
+
+
+
+ Method executed before deleting the object.
+
+
+
+
+ Method executed after deleting the object.
+
+
+
+
+ Method executed before inserting the object.
+
+
+
+
+ Method executed before updating the object.
+
+
+
+
+ Method executed after cloning the object.
+
+
+
+
+ Method executed after merging the object.
+
+
+
+
+ Method executed after refreshing the object.
+
+
+
+
+
+
+ The list of defined queries and query properties for the class.
+
+
+
+
+
+
+
+ A query definition for the class' instances.
+
+
+
+
+
+
+
+ Specifies a timeout to apply to all queries.
+
+
+
+
+ Allow the behavoir used to determine if an insert or update should occur for an object to be customized.
+
+
+
+
+ Custom insert query. This overide the default insert behavoir for usage with stored procedures or custom calls.
+
+
+
+
+ Custom update query. This overide the default update behavoir for usage with stored procedures or custom calls.
+
+
+
+
+ Custom delete query. This overide the default delete behavoir for usage with stored procedures or custom calls.
+
+
+
+
+ Custom does exist query. This overide the default delete behavoir for usage with stored procedures or custom calls.
+
+
+
+
+ Custom read object query. This overide the default read behavoir for usage with stored procedures or custom calls.
+
+
+
+
+ Custom read all query. This overide the default read all behavoir for usage with stored procedures or custom calls.
+
+
+
+
+
+
+ Defines the set of valid existence policies for determining if an insert or update should occur for an object.
+
+
+
+
+
+
+
+
+
+
+ Defines an alias for querying database information.
+
+
+
+ The query-key alias name.
+
+
+
+
+
+ The type of cache synchronization to use with a descriptor.
+
+
+
+
+
+
+
+
+
+
+ Specify how the unit of work isolated from the session cache.
+
+
+
+
+
+
+
+
+
+
+ Defines an alias for a database column.
+
+
+
+
+
+
+ The field/column being aliased.
+
+
+
+
+
+
+
+
+ Defines an alias for a join to another class' table.
+
+
+
+
+
+
+ The fully qualified name of the target referenced class.
+
+
+
+
+
+ The foreign key join condition between the source and target class' tables.
+
+
+
+
+ The join criteria between the source and target class' tables.
+
+
+
+
+
+
+
+
+
+ Defines an alias for a 1-1 join to another class' table.
+
+
+
+
+
+
+
+ Defines an alias for a 1-m join from another class' table.
+
+
+
+
+
+
+
+ Defines a mapping from an attirbute to a simple field datatype, i.e. String, Number, Date.
+
+
+
+
+
+
+ The name and optionally the table of the field/column that the attribute is stored into.
+
+
+
+
+ Optionally specify a value that null data values should be converted to.
+
+
+
+
+ Optionally specify how the data value should be converted to the object value.
+
+
+
+
+
+
+
+
+
+ Defines how a attribute is persisted. The attribute mapping definition is extendable to allow for different types of mappings.
+
+
+
+
+ The name of the attribute. This is the implementation class attribute name.
+
+
+
+
+ Specify if the attribute is read-only.
+
+
+
+
+ The name of the get method for the attribute.
+
+
+
+
+ The name of the set method for the attribute.
+
+
+
+
+ Allow for user defined properties to be defined.
+
+
+
+
+
+ A user defined property.
+
+
+
+
+
+
+
+
+
+ Defines how a simple attribute is persisted.
+
+
+
+
+
+
+
+
+ Defines a mapping from an attirbute to a simple field datatype, i.e. String, Number, Date.
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping from an attirbute to a simple field datatype, i.e. String, Number, Date.
+
+
+
+
+
+
+
+ Defines a field transformation for a transformation mapping
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a transformation mapping that uses Java code to transform between the data and object values.
+ This can be used if a single attribute maps to multiple fields, or field only mappings or attribute only mappings.
+
+
+
+
+
+
+ The name of the attribute transformation defined in the domain class.
+
+
+
+
+ The class name of the attribute transformer. Used in place of attribute-transformation.
+
+
+
+
+
+
+ The field transformations.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This can be used if a single attribute maps to multiple fields, or field only mappings or attribute only mappings.
+
+
+
+
+
+
+
+ This can be used if a single attribute maps to multiple fields, or field only mappings or attribute only mappings.
+
+
+
+
+
+
+
+ This can be used if a single attribute maps to multiple fields, or field only mappings or attribute only mappings.
+
+
+
+
+
+
+
+ Defines a relationship where the target object is strictly privately owned by the source object and stores within the source objects row
+
+
+
+
+
+
+ The fully qualified class name of the target class of the relationship.
+
+
+
+
+ Specify if a row of all nulls should be interpreted as null.
+
+
+
+
+ Allow for the mapping to use different field names than the descriptor.
+
+
+
+
+
+
+
+
+ The field in the source descriptor's table.
+
+
+
+
+ The field in the aggregate descriptor.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines how a relationship between two classes is persisted.
+
+
+
+
+
+
+ The fully qualified class name of the target class of the relationship.
+
+
+
+
+ Specify if the target objects are privately owned dependent objects.
+
+
+
+
+ Specify if the create operation should be cascaded to the referenced object.
+
+
+
+
+ Specify if the create operation should be cascaded to the referenced object.
+
+
+
+
+ Specify if the refresh operation should be cascaded to the referenced object.
+
+
+
+
+ Specify if the remove operation should be cascaded to the referenced object.
+
+
+
+
+
+
+
+
+ Defines a 1-1 relationship from the source instance to the target instance.
+
+
+
+
+
+
+ The foreign key in the source class' table that defines the relationship.
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+
+
+ For bi-directional relationships the target inverse relationship can be defined.
+
+
+
+
+ Specify to optimize reads for the class by batching the reads to this relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target objects.
+
+
+
+
+ Specify to always join the related objects.
+
+
+
+
+
+
+
+
+ Defines a 1-1 relationship from the source instance to the target instance.
+
+
+
+
+
+
+
+ Defines a 1-m relationship from the source instance to the target instances.
+
+
+
+
+
+
+ The foreign key in the target class' table that defines the relationship.
+
+
+
+
+ For bi-directional relationships the target inverse relationship can be defined.
+
+
+
+
+ Specify to optimize reads for the class by batching the reads to this relationship.
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target objects.
+
+
+
+
+ A query to delete all of the related objects can be specified.
+
+
+
+
+ Specify to always join the related objects.
+
+
+
+
+
+
+
+
+ Defines a 1-m relationship from the source instance to the target instances.
+
+
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+
+
+
+ For bi-directional relationships the target inverse relationship can be defined.
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target objects.
+
+
+
+
+ A query to delete all of the related objects can be specified.
+
+
+
+
+
+
+
+
+ Defines a collection of simple types relationship from the source instance to a set of simple data values.
+
+
+
+
+
+
+ Specify to optimize reads for the class by batching the reads to this relationship.
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target data values.
+
+
+
+
+ The name of the reference table that stores the source primary key and the data values.
+
+
+
+
+ The field/column in the reference table that stores the data values.
+
+
+
+
+ The foreign key in the reference table that defines the relationship.
+
+
+
+
+ Optionally specify how the data value should be converted to the object value.
+
+
+
+
+ A query to insert a row into the reference table can be specified.
+
+
+
+
+ A query to delete a row from the reference table can be specified.
+
+
+
+
+ A query to delete all of the rows from the reference table can be specified.
+
+
+
+
+ The name session that defines the reference table.
+
+
+
+
+ Defines how past versions of this attribute are persisted to the data-store. By default there will be no history policy.
+
+
+
+
+ Specify to always join the related objects.
+
+
+
+
+
+
+
+
+ Defines a map relationship from the source instance to a set of key values pairs of simple data values.
+
+
+
+
+
+
+ The field/column in the reference table that sores the map key data value.
+
+
+
+
+ Optionally specify how the key data value should be converted to the object value.
+
+
+
+
+
+
+
+
+ Defines a 1-m relationship from the source instance to the target instances where the target instances are strictly privately owned by the source object.
+
+
+
+
+
+
+ The foreign key in the target class' table that defines the relationship.
+
+
+
+
+ For bi-directional relationships the target inverse relationship can be defined.
+
+
+
+
+ Specify to optimize reads for the class by batching the reads to this relationship.
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target objects.
+
+
+
+
+ A query to delete all of the related objects can be specified.
+
+
+
+
+ Specify to always join the related objects.
+
+
+
+
+
+
+
+
+ Defines a m-m relationship from the source instance to the target instances.
+
+
+
+
+
+
+ The name of the relation table that stores the source/target primary keys.
+
+
+
+
+ The foreign key from the relational table to the source class' table.
+
+
+
+
+ The foreign key from the relational table to the target class' table.
+
+
+
+
+ For bi-directional relationships the target inverse relationship can be defined.
+
+
+
+
+ Specify to optimize reads for the class by batching the reads to this relationship.
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target objects.
+
+
+
+
+ A query to insert a row into the relation table can be specified.
+
+
+
+
+ A query to delete a row from the relation table can be specified.
+
+
+
+
+ A query to delete all of the rows from the relation table can be specified.
+
+
+
+
+ Defines how past versions of this attribute are persisted to the data-store. By default there will be no history policy.
+
+
+
+
+ Specify to always join the related objects.
+
+
+
+
+
+
+
+
+ Defines a 1-1 relationship from the source instance to the target instance that may be of several types related through an interface.
+
+
+
+
+
+
+ For bi-directional relationships the target inverse relationship can be defined.
+
+
+
+
+ Specify to optimize reads for the class by batching the reads to this relationship.
+
+
+
+
+ The indirection policy to use for the relationship.
+
+
+
+
+ Specify the query to use to select the target objects.
+
+
+
+
+ Specify the column to store the class type of the related object into.
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+ The set of foreign key fields populated by this relationship in the source class' table.
+
+
+
+
+
+
+
+ The list of source/target column/query key references relating a foreign key in one table to the query keys defining a primary or unique key value in the other interface descriptor.
+
+
+
+
+
+ The reference of a source table foreign key and a target interface descriptor query key.
+
+
+
+
+
+ The foreign key field/column name in the source table.
+
+
+
+
+ The query key name of the target interface descriptor.
+
+
+
+
+
+
+
+
+
+
+ The set of class indicator values and the subclasses they map to.
+
+
+
+
+
+
+
+
+ Defines a container/collection type.
+
+
+
+
+ Specifies the fully qualified class name of the collection implementation class.
+
+
+
+
+
+
+ Defines a sorted collection type.
+
+
+
+
+
+
+ Specifies the fully qualified class name of the comparitor, used to compare objects in sorting the collection.
+
+
+
+
+
+
+
+
+ Defines a list collection type.
+
+
+
+
+
+
+
+ Defines a map container type.
+
+
+
+
+
+
+ Specifies the method to call on the target objects to get the key value for the map.
+
+
+
+
+
+
+
+
+ Defines a direct map container type.
+
+
+
+
+
+
+
+ Defines a scrollable cursor container type.
+
+
+
+
+
+
+
+ Defines a cursored stream container type.
+
+
+
+
+
+
+
+ Defines a deferred read indirection mechanism.
+
+
+
+
+ Defines usage of value holders to implement indirection.
+
+
+
+
+
+
+
+ Defines usage of proxies to implement indirection.
+
+
+
+
+
+
+
+ Defines usage of transparent collections to implement indirection.
+
+
+
+
+
+
+ Specifies the fully qualified class name of the collection interface to use, i.e. List, Set, Map.
+
+
+
+
+ Specifies the method to call on the target objects to get the key value for the map.
+
+
+
+
+
+
+
+
+ Defines usage of a user defined container to implement indirection.
+
+
+
+
+
+
+ Specifies the fully qualified class name of the container implementer to use.
+
+
+
+
+
+
+
+
+ List converter
+
+
+
+
+
+
+ Specifies the fully qualified class name of the list's element type.
+
+
+
+
+
+
+
+
+ Typesafe Enumeration conversion
+
+
+
+
+
+
+
+ Specifies the data type and an object type of the attribute to convert between.
+
+
+
+
+
+
+ Specifies the fully qualified class name of the attribute type.
+
+
+
+
+ Specifies the fully qualified class name of the attributes storage data type.
+
+
+
+
+
+
+
+
+ Uses object serialization to convert between the object and data type.
+
+
+
+
+
+
+ Specifies the fully qualified class name of the attributes storage data type.
+
+
+
+
+
+
+
+
+ Specifies a mapping of values from database values used in the field and object values used in the attribute.
+
+
+
+
+
+
+ An optional default value can be specified. This value is used if a database type is not found in the type mapping.
+
+
+
+
+ Specifies the mapping of values. Both the object and database values must be unique.
+
+
+
+
+
+ Defines the object and data value mapping.
+
+
+
+
+
+
+
+ Specifies a mapping of additional values that map non-unique data values to a unique attribute value.
+
+
+
+
+
+ Defines the object and data value mapping.
+
+
+
+
+
+
+
+
+
+
+
+ Define an object and data value mapping.
+
+
+
+
+ Specifies the value to use in the object's attribute.
+
+
+
+
+ Specifies the value to use in the database field.
+
+
+
+
+
+
+ Defines a query/interaction against a database.
+
+
+
+
+
+
+ Specifies if the query should bypass the cache completely.
+
+
+
+
+ Specifies if the query should use paramater binding for arguments, or print the arguments in-line.
+
+
+
+
+ Specifies if the queries statement should be cached, this must be used with parameter binding.
+
+
+
+
+ Specifies a timeout to cancel the query in if the request takes too long to complete.
+
+
+
+
+ Specifies if the query should prepare and cache its generated SQL, or regenerate the SQL on each execution.
+
+
+
+
+ For static calls the SQL or Stored Procedure call definition can be specified.
+
+
+
+
+
+
+
+
+ Defines the set of valid join fetch options.
+
+
+
+
+
+
+
+
+
+ Defines the set of valid cascade policies.
+
+
+
+
+
+
+
+
+
+ Defines a query for reading a single value.
+
+
+
+
+
+
+
+ Defines a query for reading a collection of values.
+
+
+
+
+
+
+
+ Defines a query for reading raw data.
+
+
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+
+
+
+
+ Defines a query for reading.
+
+
+
+
+
+
+ Specifies if the query should cache the query results to avoid future executions.
+
+
+
+
+ Specifies the maximum number of rows to fetch, results will be trunctate on the database to this size.
+
+
+
+
+ Specifies where to start the cursor in a result set returned from the database. Results prior to this number will not be built into objects
+
+
+
+
+ Specifiess the number of rows to fetch from the database on each result set next operation.
+
+
+
+
+ Specify how the query results should be cached.
+
+
+
+
+
+
+
+
+ Defines how a query's results should be cached.
+
+
+
+
+ Defines the cache invalidation policy. By default there will be no cache invalidation policy.
+
+
+
+
+ This defines the number of query result sets that will be cached. The LRU query results will be discarded when the max size is reached.
+
+
+
+
+
+
+ Defines a query for manipulating data.
+
+
+
+
+
+
+
+ Defines a query for modifying an object.
+
+
+
+
+
+
+
+ Defines a query for updating an object.
+
+
+
+
+
+
+
+ Defines a query for inserting an object.
+
+
+
+
+
+
+
+ Defines a query for deleting an object.
+
+
+
+
+
+
+
+ Defines a query for determining if an object exists.
+
+
+
+
+
+
+ The existence check option.
+
+
+
+
+
+
+
+
+ Defines the set of valid existence check options.
+
+
+
+
+
+
+
+
+
+
+ Defines a query for deleting a criteria of objects.
+
+
+
+
+
+
+
+ Defines a query for objects (as apposed to data).
+
+
+
+
+
+
+ The full qualified name of the class of objects being queried.
+
+
+
+
+ Specify if the query should refresh any cached objects from the database.
+
+
+
+
+ Specify if the query should refresh any remotely cached objects from the server.
+
+
+
+
+ Specifies if the queries settings (such as refresh, maintain-cache) should apply to the object's relationship queries.
+
+
+
+
+ Specify how the query should interact with the cache.
+
+
+
+
+ Specify if the query should lock the resulting rows on the database.
+
+
+
+
+ Specify if the query should filter distinct results.
+
+
+
+
+ The in memory querying policy.
+
+
+
+
+
+ Specify how indirection or unconformable expressions should be treating with in-memory querying and conforming.
+
+
+
+
+
+
+
+ Specify if the default fetch group should be used for the query.
+
+
+
+
+ Allow the query to partially fetch the object.
+
+
+
+
+ Specify a pre-defined named fetch group to allow the query to partially fetch the object.
+
+
+
+
+ Specify if the exclusive connection (VPD) should be used for the query.
+
+
+
+
+ Specifies the attributes being joined.
+
+
+
+
+
+ Represents an expression for joining
+
+
+
+
+
+
+
+ Specify if objects resulting from the query are read-only, and will not be registered in the unit of work.
+
+
+
+
+ For inheritance queries specify if all subclasses should be outer joined, instead of a query per subclass.
+
+
+
+
+
+
+
+
+ Defines a query for a set of objects.
+
+
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+ Specifies all attributes for batch reading.
+
+
+
+
+
+ Represents an expression for batch reading
+
+
+
+
+
+
+
+ Sets the order expressions for the query.
+
+
+
+
+
+ Represents an expression for ordering
+
+
+
+
+
+
+
+
+
+
+
+ Defines a query for a single object.
+
+
+
+
+
+
+
+ Query for information about a set of objects instead of the objects themselves.
+
+
+
+
+
+
+ Simplifies the result by only returning the first result, first value, or all attribute values.
+
+
+
+
+ Indicates wether the primary key values should also be retrieved for the reference class.
+
+
+
+
+ Items to be selected, these could be attributes or aggregate functions.
+
+
+
+
+
+ Represents an item requested
+
+
+
+
+
+
+
+ Sets GROUP BY expressions for the query.
+
+
+
+
+
+ Represents an expression for grouping
+
+
+
+
+
+
+
+
+
+
+
+ Simplifies the result by only returning the first result, first value, or all attribute values.
+
+
+
+
+
+
+
+
+
+ Indicates wether the primary key values should also be retrieved for the reference class.
+
+
+
+
+
+
+
+
+
+ Represents an item requested in ReportQuery.
+
+
+
+
+ Name given for item, can be used to retieve value from result.
+
+
+
+
+ Expression (partial) that describes the attribute wanted.
+
+
+
+
+
+
+ Defines a query filter expression tree.
+
+
+
+
+
+
+
+ Defines a relation expression that compares to expressions through operators such as equal, lessThan, etc..
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a expression composed of two sub-expressions joined through an operator such as AND, OR.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a expression composed of a function applied to a list of sub-expressions.
+
+
+
+
+
+
+ The list of function arguments.
+
+
+
+
+
+ Defines an argument expression.
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an expression value. If the value is null the value tag can is absent.
+
+
+
+
+
+
+
+
+
+
+
+ Defines an expression query-key.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an expression field.
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an expression parameter.
+
+
+
+
+
+
+
+
+
+
+
+ Defines an expression builder/base.
+
+
+
+
+
+
+
+ Defines the set of valid operators.
+
+
+
+
+
+ Defines an SQL query language string.
+
+
+
+
+
+
+ The full SQL query string. Arguments can be specified through #arg-name tokens in the string.
+
+
+
+
+
+
+
+
+ Defines an EJB-QL query language string.
+
+
+
+
+
+
+ The EJB-QL query string.
+
+
+
+
+
+
+
+
+ Defines a stored procedure invocation definition.
+
+
+
+
+
+
+ The name of the stored procedure.
+
+
+
+
+ Define the call to use a cursor output parameter to define the result set.
+
+
+
+
+ The list of input and output arguments.
+
+
+
+
+
+ Defines an argument to the procedure. The order of the arguments must match the procedure arguments if not named.
+
+
+
+
+
+
+
+ The list of optional arguments.
+
+
+
+
+
+ Defines an optional argument.
+
+
+
+
+
+
+
+
+
+
+
+ Defines a stored function invocation definition.
+
+
+
+
+
+
+ The return value of the stored-function.
+
+
+
+
+
+
+
+
+ Defines a stored procedure call argument.
+
+
+
+
+ The stored procedure name of the argument. For indexed argument the name is not required.
+
+
+
+
+ The query name of the argument. This is the name of the argument as define in the query.
+
+
+
+
+ The fully qualified name of the argument class type.
+
+
+
+
+ The JDBC int type of the argument, as defined in java.jdbc.Types
+
+
+
+
+ The name of the type if procedure-argument-sqltype is STRUCT or ARRAY
+
+
+
+
+ The procedure argument value maybe be specified if not using a query argument.
+
+
+
+
+
+
+ Defines a stored procedure call output argument.
+
+
+
+
+
+
+
+ Defines a stored procedure call output argument.
+
+
+
+
+
+
+ The query name of the argument. This is the name of the argument as define in the query.
+
+
+
+
+
+
+
+
+ Defines a stored procedure invocation definition whose arguments contain at least one Oracle PL/SQL type that has no JDBC representation (e.g. BOOLEAN, PLS_INTEGER, PL/SQL record).
+
+
+
+
+
+
+ The name of the stored procedure.
+
+
+
+
+ The list of input and output arguments.
+
+
+
+
+
+ Defines an argument to the procedure.
+
+
+
+
+
+
+
+ The list of optional arguments.
+
+
+
+
+
+ Defines an optional argument.
+
+
+
+
+
+
+
+
+
+
+
+ Defines a stored function invocation definition.
+
+
+
+
+
+
+ The return value of the stored-function.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ The list of fields.
+
+
+
+
+
+ Defines an argument to the procedure.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a class mapping to an EIS record data structure.
+
+
+
+
+
+
+ The name of the record structure name the descriptor maps to.
+
+
+
+
+ The namespace resolver for the descriptor.
+
+
+
+
+
+
+
+
+ Defines an EIS interaction utilizing MappedRecord.
+
+
+
+
+
+
+ The name of the function.
+
+
+
+
+ Optional root key if the input result is not at the record root.
+
+
+
+
+ Optional root key if the output result is not at the record root.
+
+
+
+
+ The list of input arguments.
+
+
+
+
+
+
+
+
+
+ The list of output arguments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an EIS interaction utilizing XML records.
+
+
+
+
+
+
+ The name of the function.
+
+
+
+
+ The name to use for the input record, if required by the adapter.
+
+
+
+
+ Optional root key if the output result is not at the record root.
+
+
+
+
+ Optional root key if the input result is not at the record root.
+
+
+
+
+ Optional root key if the output result is not at the record root.
+
+
+
+
+ The list of input arguments.
+
+
+
+
+
+
+
+
+
+ The list of output arguments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an EIS interaction utilizing Indexed records.
+
+
+
+
+
+
+ The name of the function.
+
+
+
+
+ The list of input arguments.
+
+
+
+
+
+
+
+
+
+ The list of output arguments.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an interaction argument.
+
+
+
+
+ The procedure argument value maybe be specified if not using a query argument.
+
+
+
+
+
+ The interaction name of the argument. For indexed arguments the name is not required.
+
+
+
+
+ The query name of the argumen. This is the name of the argument as define in the query, or the descriptor field name.
+
+
+
+
+
+ Defines a class mapping to a Structure type in an object-relational database.
+
+
+
+
+
+
+ The name of the object structure type.
+
+
+
+
+ The ordered list of the field defined in the structure.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a 1-m/m-m relationship that makes use of the object-relational nested-table type.
+
+
+
+
+
+
+ The field/column in the source table that stores the nested-table.
+
+
+
+
+ Specify the object-relational type name of the nested-table type.
+
+
+
+
+
+
+
+
+ Defines a collection of primitive/simple type values using the object-relational array type.
+
+
+
+
+
+
+ Specify the object-relational type name of the structure type.
+
+
+
+
+
+
+
+
+ Defines a collection of object-types using the object-relational array type.
+
+
+
+
+
+
+ Specify the object-relational type name of the structure type.
+
+
+
+
+
+
+
+
+ Defines a structure of object-types using the object-relational structure type.
+
+
+
+
+
+
+
+ Defines a reference to another object-type using the object-relational reference type.
+
+
+
+
+
+
+ The field in the source type that stores the reference.
+
+
+
+
+
+
+
+
+ Defines an ObjectRelationalDatabaseField
+
+
+
+
+
+
+
+
+
+
+
+ Defines a direct mapping to an Oracle XDB XML Type.
+
+
+
+
+
+
+
+
+
+
+
+ Defines a direct collection mapping for an XML list of elements.
+
+
+
+
+
+
+
+ Optionally specify how the data value should be converted to the object value.
+
+
+
+
+ Optionally specify a user defined converter class.
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+
+
+
+
+ Defines a 1-M relationship from the source XML element to the target XML element based on a key.
+
+
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+
+
+
+
+
+
+ Defines a 1-1 relationship from the source XML element to the target XML element based on one or more keys.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a direct collection mapping for an XML list of elements.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a direct collection mapping for an XML list of elements.
+
+
+
+
+
+
+
+ Defines a composite collection mapping for an XML list of nested elements.
+
+
+
+
+
+
+
+
+ Defines the collection type to use for the relationship.
+
+
+
+
+
+
+
+
+ Defines a composite collection mapping for an XML list of nested elements.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a composite collection mapping for an XML list of nested elements.
+
+
+
+
+
+
+
+ Defines a composite object mapping for an XML nested element.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a composite object mapping for an XML nested element.
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a composite object mapping for an XML nested element.
+
+
+
+
+
+
+
+ Defines a class mapping to an XML element.
+
+
+
+
+
+
+ The name of the element the descriptor maps to.
+
+
+
+
+ The XMLField representing the default root element of the descriptor.
+
+
+
+
+ Indicates if nodes should be cached to preserve unmapped data
+
+
+
+
+ The namespace resolver for the descriptor.
+
+
+
+
+ The location of the XML Schema.
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a collection to an xs:any declaration or xs:anyType element
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a collection to an xs:any declaration or xs:anyType element
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a single object to an xs:any declaration
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a single Node to a fragment of an XML document
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a collection of Nodes to a fragment of an XML document
+
+
+
+
+
+
+
+ Defines a mapping of a binary object to base64 binary
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a binary object to base64 binary
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a collection to a choice structure in an xml document
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines a mapping of a collection to a choice structure in an xml document
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines an XPath expression to an element or attribute in an XML document.
+
+
+
+
+
+
+ The position of the node in the parent type.
+
+
+
+
+ If this is a typed text field.
+
+
+
+
+ Indicates if each item in the collection is in the same node instead of having one node per item in the collection
+
+
+
+
+ The schema type of the element.
+
+
+
+
+
+
+ Indicates the elements type.
+
+
+
+
+
+
+
+
+
+ Use to represent nodes which are mapped to unions
+
+
+
+
+
+
+ If this is a typed text field.
+
+
+
+
+ Indicates if each item in the collection is in the same node instead of having one node per item in the collection
+
+
+
+
+ The schema type of the element.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Defines the cmp bean-level pessimistic locking policy.
+
+
+
+
+ Defines modification deferral level for non-deferred writes.
+
+
+
+
+ Defines point at which insert will be issued to Database.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Holds the pessimistic locking mode.
+
+
+
+
+
+
+
+
+ Sequence object.
+
+
+
+
+ Sequence name.
+
+
+
+
+ Sequence preallocation size.
+
+
+
+
+
+
+ References default sequence object, overriding its name and (optionally) preallocation size.
+ To use preallocation size of default sequence object, set preallocation size to 0
+
+
+
+
+
+
+
+ Database sequence mechanism used.
+
+
+
+
+
+
+
+ Table sequence
+
+
+
+
+
+
+ Define the name of the sequence table.
+
+
+
+
+ Define the name of the sequence name field in the sequence table.
+
+
+
+
+ Define the name of the sequence counter field in the sequence table.
+
+
+
+
+
+
+
+
+ Unary table sequence - sequence name is a table name, table has a single field and a single row
+
+
+
+
+
+
+ Define the name of the sequence counter field in the sequence table.
+
+
+
+
+
+
+
+
+ Xmlfile sequence.
+
+
+
+
+
+
+
+ Xml sequence
+
+
+
+
+
+
+ Define the name of the sequence table.
+
+
+
+
+ Define the name of the sequence name field in the sequence table.
+
+
+
+
+ Define the name of the sequence counter field in the sequence table.
+
+
+
+
+
+
+
+
+ Contains all pre-defined fetch groups.
+
+
+
+
+
+
+
+
+ Contains the fetch group attributes info.
+
+
+
+
+
+
+ Contains a fetch group's attribute list.
+
+
+
+
+
+
+
+
+
+
+ Describes the change tracking policy for this descriptor.
+
+
+
+
+ Uses backup clone to detect changes.
+
+
+
+
+
+
+
+ Uses "mark dirty" to detect changes.
+
+
+
+
+
+
+
+ Uses a ChangeTracker firing PropertyChangeEvent's to detect changes.
+
+
+
+
+
+
+
+ Defines the Null Policy in use for this relationship currently a choice of [NullPolicy and IsSetNullPolicy].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Write null, no tag(default) or an empty tag.
+
+
+
+
+
+
+
+
+
+ Defines a generic field concept, such as a database column.
+
+
+
+ The name of the field.
+
+
+
+
+
+ Defines a column in a relational database table.
+
+
+
+
+
+ The name of the column's table. This table must be listed in the class' tables. If not specified the first table of the class will be used.
+
+
+
+
+ (optional field) The JDBC typecode of this column
+
+
+
+
+ (optional field) Name of the JDBC typecode for this column
+
+
+
+
+
+
+
+ The list of source/target field/column references relating a foreign key in one table to the primary or unique key in another table.
+
+
+
+
+ The reference of a source table foreign key and a target table primary key.
+
+
+
+
+
+ The foreign key field/column name in the source table.
+
+
+
+
+ The primary or unique key field/column name in the target table.
+
+
+
+
+
+
+
+
+
+ Defines a query specification for querying instances of the class.
+
+
+
+
+ The selection criteria of the query.
+
+
+
+
+ The list of query arguments. The order of the argument must match the order of the argument value passed to the query.
+
+
+
+
+
+ The query argument.
+
+
+
+
+
+
+
+
+ The name of the query. This name can be used to reference and execute the query.
+
+
+
+
+
+ Defines the filtering clause of a query.
+
+
+
+
+ Defines a query argument.
+
+
+
+
+ The fully qualified class type name of the argument may be provided.
+
+
+
+
+ Optional constant value for the argument.
+
+
+
+
+ Defines if the argument is nullable.
+
+
+
+
+
+ The name of the query argument.
+
+
+
+
+
+ A user defined property.
+
+
+
+
+
+
+
+
+ The list of tables that the class is persisted to. This is typically a single table but can be multiple, or empty for inheritance or aggregated classes.
+
+
+
+ The name of the table. The name can be fully qualified with the schema, tablespace or link.
+
+
+
+
+
+
+ Specifies how the data value should be converted to the
+ object value.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--
cgit v1.2.3