You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1079 lines
45 KiB
1079 lines
45 KiB
7 years ago
|
<!--
|
||
|
~ Hibernate, Relational Persistence for Idiomatic Java
|
||
|
~
|
||
|
~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
||
|
~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
||
|
-->
|
||
|
|
||
|
<!-- Hibernate Mapping DTD.
|
||
|
|
||
|
<!DOCTYPE hibernate-mapping PUBLIC
|
||
|
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
|
||
|
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
|
||
|
|
||
|
An instance of this XML document may contain mappings for an arbitrary
|
||
|
number of classes. The class mappings may contain associations to classes
|
||
|
mapped in the same document or in another document. No class may be
|
||
|
mapped more than once. Each document may also contain definitions of an
|
||
|
arbitrary number of queries, and import declarations of arbitrary classes.
|
||
|
|
||
|
-->
|
||
|
|
||
|
<!--
|
||
|
The document root.
|
||
|
-->
|
||
|
|
||
|
<!ELEMENT hibernate-mapping (
|
||
|
meta*,
|
||
|
identifier-generator*,
|
||
|
typedef*,
|
||
|
filter-def*,
|
||
|
import*,
|
||
|
(class|subclass|joined-subclass|union-subclass)*,
|
||
|
resultset*,
|
||
|
(query|sql-query)*,
|
||
|
filter-def*,
|
||
|
fetch-profile*,
|
||
|
database-object*
|
||
|
)>
|
||
|
<!ATTLIST hibernate-mapping schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST hibernate-mapping catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST hibernate-mapping default-cascade CDATA "none">
|
||
|
<!ATTLIST hibernate-mapping default-access CDATA "property">
|
||
|
<!ATTLIST hibernate-mapping default-lazy (true|false) "true">
|
||
|
<!ATTLIST hibernate-mapping auto-import (true|false) "true">
|
||
|
<!ATTLIST hibernate-mapping package CDATA #IMPLIED> <!-- default: none -->
|
||
|
|
||
|
<!--
|
||
|
<meta.../> is used to assign meta-level attributes to a class
|
||
|
or property. Is currently used by codegenerator as a placeholder for
|
||
|
values that is not directly related to OR mappings.
|
||
|
-->
|
||
|
<!ELEMENT meta (#PCDATA)>
|
||
|
<!ATTLIST meta attribute CDATA #REQUIRED>
|
||
|
<!ATTLIST meta inherit (true|false) "true">
|
||
|
|
||
|
<!--
|
||
|
<identifier-generator.../> allows customized short-naming of IdentifierGenerator implementations.
|
||
|
-->
|
||
|
<!ELEMENT identifier-generator EMPTY>
|
||
|
<!ATTLIST identifier-generator name CDATA #REQUIRED>
|
||
|
<!ATTLIST identifier-generator class CDATA #REQUIRED>
|
||
|
|
||
|
<!--
|
||
|
<typedef.../> allows defining a customized type mapping for a Hibernate type. May
|
||
|
contain parameters for parameterizable types.
|
||
|
-->
|
||
|
<!ELEMENT typedef (param*)>
|
||
|
<!ATTLIST typedef class CDATA #REQUIRED>
|
||
|
<!ATTLIST typedef name CDATA #REQUIRED>
|
||
|
|
||
|
<!--
|
||
|
IMPORT element definition; an explicit query language "import"
|
||
|
-->
|
||
|
<!ELEMENT import EMPTY>
|
||
|
<!ATTLIST import class CDATA #REQUIRED>
|
||
|
<!ATTLIST import rename CDATA #IMPLIED> <!-- default: unqualified class name -->
|
||
|
|
||
|
<!--
|
||
|
Root entity mapping. Poorly named as entities do not have to be represented by
|
||
|
classes at all. Mapped entities may be represented via different methodologies
|
||
|
(POJO, Map, Dom4j).
|
||
|
-->
|
||
|
<!ELEMENT class (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
tuplizer*,
|
||
|
(id|composite-id),
|
||
|
discriminator?,
|
||
|
natural-id?,
|
||
|
(version|timestamp)?,
|
||
|
(property|many-to-one|one-to-one|component|dynamic-component|properties|any|map|set|list|bag|idbag|array|primitive-array)*,
|
||
|
((join*,subclass*)|joined-subclass*|union-subclass*),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,
|
||
|
filter*,
|
||
|
fetch-profile*,
|
||
|
resultset*,
|
||
|
(query|sql-query)*
|
||
|
)>
|
||
|
<!ATTLIST class entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST class name CDATA #IMPLIED> <!-- this is the class name -->
|
||
|
<!ATTLIST class proxy CDATA #IMPLIED> <!-- default: no proxy interface -->
|
||
|
<!ATTLIST class lazy (true|false) #IMPLIED>
|
||
|
<!ATTLIST class table CDATA #IMPLIED> <!-- default: unqualified classname -->
|
||
|
<!ATTLIST class schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST class catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST class subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST class discriminator-value CDATA #IMPLIED> <!-- default: unqualified class name | none -->
|
||
|
<!ATTLIST class mutable (true|false) "true">
|
||
|
<!ATTLIST class abstract (true|false) #IMPLIED>
|
||
|
<!ATTLIST class polymorphism (implicit|explicit) "implicit">
|
||
|
<!ATTLIST class where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST class persister CDATA #IMPLIED>
|
||
|
<!ATTLIST class dynamic-update (true|false) "false">
|
||
|
<!ATTLIST class dynamic-insert (true|false) "false">
|
||
|
<!ATTLIST class batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST class select-before-update (true|false) "false">
|
||
|
<!ATTLIST class optimistic-lock (none|version|dirty|all) "version">
|
||
|
<!ATTLIST class check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST class rowid CDATA #IMPLIED>
|
||
|
<!ATTLIST class node CDATA #IMPLIED>
|
||
|
|
||
|
<!--
|
||
|
TUPLIZER element; defines tuplizer to use for a component/entity for a given entity-mode
|
||
|
-->
|
||
|
<!ELEMENT tuplizer EMPTY>
|
||
|
<!ATTLIST tuplizer entity-mode (pojo|dom4j|dynamic-map) #IMPLIED> <!-- entity mode for which tuplizer is in effect -->
|
||
|
<!ATTLIST tuplizer class CDATA #REQUIRED> <!-- the tuplizer class to use -->
|
||
|
|
||
|
<!--
|
||
|
FILTER-DEF element; top-level filter definition.
|
||
|
-->
|
||
|
<!ELEMENT filter-def (#PCDATA|filter-param)*>
|
||
|
<!ATTLIST filter-def name CDATA #REQUIRED> <!-- The filter name -->
|
||
|
<!ATTLIST filter-def condition CDATA #IMPLIED>
|
||
|
|
||
|
<!--
|
||
|
FILTER-PARAM element; qualifies parameters found within a FILTER-DEF
|
||
|
condition.
|
||
|
-->
|
||
|
<!ELEMENT filter-param EMPTY>
|
||
|
<!ATTLIST filter-param name CDATA #REQUIRED> <!-- The parameter name -->
|
||
|
<!ATTLIST filter-param type CDATA #REQUIRED> <!-- The parameter type -->
|
||
|
|
||
|
<!--
|
||
|
FILTER element; used to apply a filter.
|
||
|
-->
|
||
|
<!ELEMENT filter (#PCDATA)>
|
||
|
<!ATTLIST filter name CDATA #REQUIRED>
|
||
|
<!ATTLIST filter condition CDATA #IMPLIED>
|
||
|
|
||
|
<!--
|
||
|
-->
|
||
|
<!ELEMENT fetch-profile (fetch*)>
|
||
|
<!ATTLIST fetch-profile name CDATA #REQUIRED>
|
||
|
|
||
|
<!--
|
||
|
The <fetch> element defines a single path to which the fetch
|
||
|
refers, as well as the style of fetch to apply. The 'root' of the
|
||
|
path is different depending upon the context in which the
|
||
|
containing <fetch-profile/> occurs; within a <class/> element,
|
||
|
the entity-name of the containing class mapping is assumed...
|
||
|
-->
|
||
|
<!ELEMENT fetch EMPTY>
|
||
|
<!ATTLIST fetch entity CDATA #IMPLIED> <!-- Implied as long as the containing fetch profile is contained in a class mapping -->
|
||
|
<!ATTLIST fetch association CDATA #REQUIRED>
|
||
|
<!ATTLIST fetch style (join|select) "join">
|
||
|
|
||
|
<!-- A join allows some properties of a class to be persisted to a second table -->
|
||
|
|
||
|
<!ELEMENT join (
|
||
|
subselect?,
|
||
|
comment?,
|
||
|
key,
|
||
|
(property|many-to-one|component|dynamic-component|any)*,
|
||
|
sql-insert?,sql-update?,sql-delete?
|
||
|
)>
|
||
|
<!ATTLIST join table CDATA #REQUIRED>
|
||
|
<!ATTLIST join schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST join catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST join subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST join fetch (join|select) "join">
|
||
|
<!ATTLIST join inverse (true|false) "false">
|
||
|
<!ATTLIST join optional (true|false) "false">
|
||
|
|
||
|
<!-- A natural-id element allows declaration of the unique business key -->
|
||
|
|
||
|
<!ELEMENT natural-id ( (property|many-to-one|component|dynamic-component|any)* )>
|
||
|
<!ATTLIST natural-id mutable (true|false) "false">
|
||
|
|
||
|
<!-- Declares the id type, column and generation algorithm for an entity class.
|
||
|
If a name attribut is given, the id is exposed to the application through the
|
||
|
named property of the class. If not, the id is only exposed to the application
|
||
|
via Session.getIdentifier() -->
|
||
|
|
||
|
<!ELEMENT id (meta*,column*,type?,generator?)>
|
||
|
<!ATTLIST id name CDATA #IMPLIED>
|
||
|
<!ATTLIST id node CDATA #IMPLIED>
|
||
|
<!ATTLIST id access CDATA #IMPLIED>
|
||
|
<!ATTLIST id column CDATA #IMPLIED>
|
||
|
<!ATTLIST id type CDATA #IMPLIED>
|
||
|
<!ATTLIST id length CDATA #IMPLIED>
|
||
|
<!ATTLIST id unsaved-value CDATA #IMPLIED> <!-- any|none|null|undefined|0|-1|... -->
|
||
|
|
||
|
<!-- A composite key may be modelled by a java class with a property for each
|
||
|
key column. The class must implement java.io.Serializable and reimplement equals()
|
||
|
and hashCode(). -->
|
||
|
|
||
|
<!ELEMENT composite-id ( meta*, (key-property|key-many-to-one)+, generator? )>
|
||
|
<!ATTLIST composite-id class CDATA #IMPLIED>
|
||
|
<!ATTLIST composite-id mapped (true|false) "false">
|
||
|
<!ATTLIST composite-id name CDATA #IMPLIED>
|
||
|
<!ATTLIST composite-id node CDATA #IMPLIED>
|
||
|
<!ATTLIST composite-id access CDATA #IMPLIED>
|
||
|
<!ATTLIST composite-id unsaved-value (undefined|any|none) "undefined">
|
||
|
|
||
|
<!-- Polymorphic data requires a column holding a class discriminator value. This
|
||
|
value is not directly exposed to the application. -->
|
||
|
|
||
|
<!ELEMENT discriminator ((column|formula)?)>
|
||
|
<!ATTLIST discriminator column CDATA #IMPLIED> <!-- default: "class"|none -->
|
||
|
<!ATTLIST discriminator formula CDATA #IMPLIED>
|
||
|
<!ATTLIST discriminator type CDATA "string">
|
||
|
<!ATTLIST discriminator not-null (true|false) "true">
|
||
|
<!ATTLIST discriminator length CDATA #IMPLIED>
|
||
|
<!ATTLIST discriminator force (true|false) "false">
|
||
|
<!ATTLIST discriminator insert (true|false) "true">
|
||
|
|
||
|
<!-- Versioned data requires a column holding a version number. This is exposed to the
|
||
|
application through a property of the Java class. -->
|
||
|
|
||
|
<!ELEMENT version (meta*,column*)>
|
||
|
<!ATTLIST version name CDATA #REQUIRED>
|
||
|
<!ATTLIST version node CDATA #IMPLIED>
|
||
|
<!ATTLIST version access CDATA #IMPLIED>
|
||
|
<!ATTLIST version column CDATA #IMPLIED>
|
||
|
<!ATTLIST version type CDATA "integer">
|
||
|
<!ATTLIST version unsaved-value (null|negative|undefined) "undefined">
|
||
|
<!ATTLIST version generated (never|always) "never">
|
||
|
<!ATTLIST version insert (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT timestamp (meta*)>
|
||
|
<!ATTLIST timestamp name CDATA #REQUIRED>
|
||
|
<!ATTLIST timestamp node CDATA #IMPLIED>
|
||
|
<!ATTLIST timestamp column CDATA #IMPLIED>
|
||
|
<!ATTLIST timestamp access CDATA #IMPLIED>
|
||
|
<!ATTLIST timestamp unsaved-value (null|undefined) "null">
|
||
|
<!ATTLIST timestamp source (vm|db) "vm">
|
||
|
<!ATTLIST timestamp generated (never|always) "never">
|
||
|
|
||
|
|
||
|
<!--
|
||
|
Subclass declarations are nested beneath the root class declaration to achieve
|
||
|
polymorphic persistence with the table-per-hierarchy mapping strategy.
|
||
|
|
||
|
See the note on the class element regarding <pojo/> vs. @name usage...
|
||
|
-->
|
||
|
<!ELEMENT subclass (
|
||
|
meta*,
|
||
|
tuplizer*,
|
||
|
synchronize*,
|
||
|
(property|many-to-one|one-to-one|component|dynamic-component|any|map|set|list|bag|idbag|array|primitive-array)*,
|
||
|
join*,
|
||
|
subclass*,
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,
|
||
|
fetch-profile*,
|
||
|
resultset*,
|
||
|
(query|sql-query)*
|
||
|
)>
|
||
|
<!ATTLIST subclass entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST subclass name CDATA #IMPLIED>
|
||
|
<!ATTLIST subclass proxy CDATA #IMPLIED> <!-- default: no proxy interface -->
|
||
|
<!ATTLIST subclass discriminator-value CDATA #IMPLIED> <!-- default: unqualified class name | none -->
|
||
|
<!ATTLIST subclass dynamic-update (true|false) "false">
|
||
|
<!ATTLIST subclass dynamic-insert (true|false) "false">
|
||
|
<!ATTLIST subclass select-before-update (true|false) "false">
|
||
|
<!ATTLIST subclass extends CDATA #IMPLIED> <!-- default: empty when a toplevel, otherwise the nearest class definition -->
|
||
|
<!ATTLIST subclass lazy (true|false) #IMPLIED>
|
||
|
<!ATTLIST subclass abstract (true|false) #IMPLIED>
|
||
|
<!ATTLIST subclass persister CDATA #IMPLIED>
|
||
|
<!ATTLIST subclass batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST subclass node CDATA #IMPLIED>
|
||
|
|
||
|
<!--
|
||
|
Joined subclasses are used for the normalized table-per-subclass mapping strategy
|
||
|
|
||
|
See the note on the class element regarding <pojo/> vs. @name usage...
|
||
|
-->
|
||
|
<!ELEMENT joined-subclass (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
tuplizer*,
|
||
|
key,
|
||
|
(property|many-to-one|one-to-one|component|dynamic-component|properties|any|map|set|list|bag|idbag|array|primitive-array)*,
|
||
|
joined-subclass*,
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,
|
||
|
fetch-profile*,
|
||
|
resultset*,
|
||
|
(query|sql-query)*
|
||
|
)>
|
||
|
<!ATTLIST joined-subclass entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass name CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass proxy CDATA #IMPLIED> <!-- default: no proxy interface -->
|
||
|
<!ATTLIST joined-subclass table CDATA #IMPLIED> <!-- default: unqualified class name -->
|
||
|
<!ATTLIST joined-subclass schema CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass catalog CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass dynamic-update (true|false) "false">
|
||
|
<!ATTLIST joined-subclass dynamic-insert (true|false) "false">
|
||
|
<!ATTLIST joined-subclass select-before-update (true|false) "false">
|
||
|
<!ATTLIST joined-subclass extends CDATA #IMPLIED> <!-- default: none when toplevel, otherwise the nearest class definition -->
|
||
|
<!ATTLIST joined-subclass lazy (true|false) #IMPLIED>
|
||
|
<!ATTLIST joined-subclass abstract (true|false) #IMPLIED>
|
||
|
<!ATTLIST joined-subclass persister CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST joined-subclass batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST joined-subclass node CDATA #IMPLIED>
|
||
|
|
||
|
<!--
|
||
|
Union subclasses are used for the table-per-concrete-class mapping strategy
|
||
|
|
||
|
See the note on the class element regarding <pojo/> vs. @name usage...
|
||
|
-->
|
||
|
<!ELEMENT union-subclass (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
tuplizer*,
|
||
|
(property|many-to-one|one-to-one|component|dynamic-component|properties|any|map|set|list|bag|idbag|array|primitive-array)*,
|
||
|
union-subclass*,
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,
|
||
|
fetch-profile*,
|
||
|
resultset*,
|
||
|
(query|sql-query)*
|
||
|
)>
|
||
|
<!ATTLIST union-subclass entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass name CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass proxy CDATA #IMPLIED> <!-- default: no proxy interface -->
|
||
|
<!ATTLIST union-subclass table CDATA #IMPLIED> <!-- default: unqualified class name -->
|
||
|
<!ATTLIST union-subclass schema CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass catalog CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass dynamic-update (true|false) "false">
|
||
|
<!ATTLIST union-subclass dynamic-insert (true|false) "false">
|
||
|
<!ATTLIST union-subclass select-before-update (true|false) "false">
|
||
|
<!ATTLIST union-subclass extends CDATA #IMPLIED> <!-- default: none when toplevel, otherwise the nearest class definition -->
|
||
|
<!ATTLIST union-subclass lazy (true|false) #IMPLIED>
|
||
|
<!ATTLIST union-subclass abstract (true|false) #IMPLIED>
|
||
|
<!ATTLIST union-subclass persister CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST union-subclass batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST union-subclass node CDATA #IMPLIED>
|
||
|
|
||
|
<!-- Property of an entity class or component, component-element, composite-id, etc.
|
||
|
JavaBeans style properties are mapped to table columns. -->
|
||
|
|
||
|
<!ELEMENT property (meta*,(column|formula)*,type?)>
|
||
|
<!ATTLIST property name CDATA #REQUIRED>
|
||
|
<!ATTLIST property node CDATA #IMPLIED>
|
||
|
<!ATTLIST property access CDATA #IMPLIED>
|
||
|
<!ATTLIST property type CDATA #IMPLIED>
|
||
|
<!ATTLIST property column CDATA #IMPLIED>
|
||
|
<!ATTLIST property length CDATA #IMPLIED>
|
||
|
<!ATTLIST property precision CDATA #IMPLIED>
|
||
|
<!ATTLIST property scale CDATA #IMPLIED>
|
||
|
<!ATTLIST property not-null (true|false) #IMPLIED>
|
||
|
<!ATTLIST property unique (true|false) "false">
|
||
|
<!ATTLIST property unique-key CDATA #IMPLIED>
|
||
|
<!ATTLIST property index CDATA #IMPLIED> <!-- include the columns spanned by this property in an index -->
|
||
|
<!ATTLIST property update (true|false) #IMPLIED>
|
||
|
<!ATTLIST property insert (true|false) #IMPLIED>
|
||
|
<!ATTLIST property optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST property formula CDATA #IMPLIED>
|
||
|
<!ATTLIST property lazy (true|false) "false">
|
||
|
<!ATTLIST property generated (never|insert|always) "never">
|
||
|
|
||
|
<!-- Declares the type of the containing property (overrides an eventually existing type
|
||
|
attribute of the property). May contain param elements to customize a ParametrizableType. -->
|
||
|
<!ELEMENT type (param*)>
|
||
|
<!ATTLIST type name CDATA #REQUIRED>
|
||
|
|
||
|
<!-- Declares an association between two entities (Or from a component, component element,
|
||
|
etc. to an entity). -->
|
||
|
|
||
|
<!ELEMENT many-to-one (meta*,(column|formula)*)>
|
||
|
<!ATTLIST many-to-one name CDATA #REQUIRED>
|
||
|
<!ATTLIST many-to-one access CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one class CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one column CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one not-null (true|false) #IMPLIED>
|
||
|
<!ATTLIST many-to-one unique (true|false) "false">
|
||
|
<!ATTLIST many-to-one unique-key CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one index CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST many-to-one fetch (join|select) #IMPLIED>
|
||
|
<!ATTLIST many-to-one update (true|false) "true">
|
||
|
<!ATTLIST many-to-one insert (true|false) "true">
|
||
|
<!ATTLIST many-to-one optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST many-to-one foreign-key CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one property-ref CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one formula CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one lazy (false|proxy|no-proxy) #IMPLIED>
|
||
|
<!ATTLIST many-to-one not-found (exception|ignore) "exception">
|
||
|
<!ATTLIST many-to-one node CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-one embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!-- Declares a one-to-one association between two entities (Or from a component,
|
||
|
component element, etc. to an entity). -->
|
||
|
|
||
|
<!ELEMENT one-to-one (meta*,formula*)>
|
||
|
<!ATTLIST one-to-one name CDATA #REQUIRED>
|
||
|
<!ATTLIST one-to-one formula CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one access CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one class CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST one-to-one fetch (join|select) #IMPLIED>
|
||
|
<!ATTLIST one-to-one constrained (true|false) "false">
|
||
|
<!ATTLIST one-to-one foreign-key CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one property-ref CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one lazy (false|proxy|no-proxy) #IMPLIED>
|
||
|
<!ATTLIST one-to-one node CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-one embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!-- A property embedded in a composite identifier or map index (always not-null). -->
|
||
|
|
||
|
<!ELEMENT key-property (meta*,column*,type?)>
|
||
|
<!ATTLIST key-property name CDATA #REQUIRED>
|
||
|
<!ATTLIST key-property access CDATA #IMPLIED>
|
||
|
<!ATTLIST key-property type CDATA #IMPLIED>
|
||
|
<!ATTLIST key-property column CDATA #IMPLIED>
|
||
|
<!ATTLIST key-property length CDATA #IMPLIED>
|
||
|
<!ATTLIST key-property node CDATA #IMPLIED>
|
||
|
|
||
|
<!-- A many-to-one association embedded in a composite identifier or map index
|
||
|
(always not-null, never cascade). -->
|
||
|
|
||
|
<!ELEMENT key-many-to-one (meta*,column*)>
|
||
|
<!ATTLIST key-many-to-one name CDATA #REQUIRED>
|
||
|
<!ATTLIST key-many-to-one access CDATA #IMPLIED>
|
||
|
<!ATTLIST key-many-to-one class CDATA #IMPLIED>
|
||
|
<!ATTLIST key-many-to-one entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST key-many-to-one column CDATA #IMPLIED>
|
||
|
<!ATTLIST key-many-to-one foreign-key CDATA #IMPLIED>
|
||
|
<!ATTLIST key-many-to-one lazy (false|proxy) #IMPLIED>
|
||
|
<!ATTLIST key-many-to-one on-delete (cascade|noaction) "noaction">
|
||
|
|
||
|
<!-- An "any" association is a polymorphic association to any table with
|
||
|
the given identifier type. The first listed column is a VARCHAR column
|
||
|
holding the name of the class (for that row). -->
|
||
|
|
||
|
<!ELEMENT any (meta*,meta-value*,column,column+)>
|
||
|
<!ATTLIST any id-type CDATA #REQUIRED>
|
||
|
<!ATTLIST any meta-type CDATA #IMPLIED> <!--- default: Hibernate.STRING -->
|
||
|
<!ATTLIST any name CDATA #REQUIRED>
|
||
|
<!ATTLIST any access CDATA #IMPLIED>
|
||
|
<!ATTLIST any insert (true|false) "true">
|
||
|
<!ATTLIST any update (true|false) "true">
|
||
|
<!ATTLIST any cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST any index CDATA #IMPLIED> <!-- include the columns spanned by this association in an index -->
|
||
|
<!ATTLIST any optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST any lazy (true|false) "false">
|
||
|
<!ATTLIST any node CDATA #IMPLIED>
|
||
|
|
||
|
<!ELEMENT meta-value EMPTY>
|
||
|
<!ATTLIST meta-value value CDATA #REQUIRED>
|
||
|
<!ATTLIST meta-value class CDATA #REQUIRED>
|
||
|
|
||
|
<!-- A component is a user-defined class, persisted along with its containing entity
|
||
|
to the table of the entity class. JavaBeans style properties of the component are
|
||
|
mapped to columns of the table of the containing entity. A null component reference
|
||
|
is mapped to null values in all columns and vice versa. Components do not support
|
||
|
shared reference semantics. -->
|
||
|
|
||
|
<!ELEMENT component (
|
||
|
meta*,
|
||
|
tuplizer*,
|
||
|
parent?,
|
||
|
(property|many-to-one|one-to-one|component|dynamic-component|any|map|set|list|bag|array|primitive-array)*
|
||
|
)>
|
||
|
<!ATTLIST component class CDATA #IMPLIED>
|
||
|
<!ATTLIST component name CDATA #REQUIRED>
|
||
|
<!ATTLIST component access CDATA #IMPLIED>
|
||
|
<!ATTLIST component unique (true|false) "false">
|
||
|
<!ATTLIST component update (true|false) "true">
|
||
|
<!ATTLIST component insert (true|false) "true">
|
||
|
<!ATTLIST component lazy (true|false) "false">
|
||
|
<!ATTLIST component optimistic-lock (true|false) "true">
|
||
|
<!ATTLIST component node CDATA #IMPLIED>
|
||
|
|
||
|
<!-- A dynamic-component maps columns of the database entity to a java.util.Map
|
||
|
at the Java level -->
|
||
|
|
||
|
<!ELEMENT dynamic-component (
|
||
|
(property|many-to-one|one-to-one|component|dynamic-component|any|map|set|list|bag|array|primitive-array)*
|
||
|
)>
|
||
|
<!ATTLIST dynamic-component name CDATA #REQUIRED>
|
||
|
<!ATTLIST dynamic-component access CDATA #IMPLIED>
|
||
|
<!ATTLIST dynamic-component unique (true|false) "false">
|
||
|
<!ATTLIST dynamic-component update (true|false) "true">
|
||
|
<!ATTLIST dynamic-component insert (true|false) "true">
|
||
|
<!ATTLIST dynamic-component optimistic-lock (true|false) "true">
|
||
|
<!ATTLIST dynamic-component node CDATA #IMPLIED>
|
||
|
|
||
|
<!-- properties declares that the contained properties form an alternate key. The name
|
||
|
attribute allows an alternate key to be used as the target of a property-ref. -->
|
||
|
|
||
|
<!ELEMENT properties (
|
||
|
(property|many-to-one|component|dynamic-component)*
|
||
|
)>
|
||
|
<!ATTLIST properties name CDATA #REQUIRED>
|
||
|
<!ATTLIST properties unique (true|false) "false">
|
||
|
<!ATTLIST properties insert (true|false) "true">
|
||
|
<!ATTLIST properties update (true|false) "true">
|
||
|
<!ATTLIST properties optimistic-lock (true|false) "true">
|
||
|
<!ATTLIST properties node CDATA #IMPLIED>
|
||
|
|
||
|
<!-- The parent element maps a property of the component class as a pointer back to
|
||
|
the owning entity. -->
|
||
|
|
||
|
<!ELEMENT parent EMPTY>
|
||
|
<!ATTLIST parent name CDATA #REQUIRED>
|
||
|
|
||
|
<!-- Collection declarations nested inside a class declaration indicate a foreign key
|
||
|
relationship from the collection table to the enclosing class. -->
|
||
|
|
||
|
<!ELEMENT map (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
key,
|
||
|
(map-key|composite-map-key|map-key-many-to-many|index|composite-index|index-many-to-many|index-many-to-any),
|
||
|
(element|one-to-many|many-to-many|composite-element|many-to-any),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,
|
||
|
filter*
|
||
|
)>
|
||
|
<!ATTLIST map name CDATA #REQUIRED>
|
||
|
<!ATTLIST map access CDATA #IMPLIED>
|
||
|
<!ATTLIST map table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST map schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST map subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST map catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST map lazy (true|false|extra) #IMPLIED>
|
||
|
<!ATTLIST map mutable (true|false) "true">
|
||
|
<!ATTLIST map inverse (true|false) "false">
|
||
|
<!ATTLIST map sort CDATA "unsorted"> <!-- unsorted|natural|"comparator class", default: unsorted -->
|
||
|
<!ATTLIST map cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST map order-by CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST map where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST map batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST map outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST map fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST map check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST map persister CDATA #IMPLIED>
|
||
|
<!ATTLIST map collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST map optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST map node CDATA #IMPLIED>
|
||
|
<!ATTLIST map embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT set (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
key,
|
||
|
(element|one-to-many|many-to-many|composite-element|many-to-any),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,
|
||
|
filter*
|
||
|
)>
|
||
|
<!ATTLIST set name CDATA #REQUIRED>
|
||
|
<!ATTLIST set access CDATA #IMPLIED>
|
||
|
<!ATTLIST set table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST set schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST set catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST set subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST set lazy (true|false|extra) #IMPLIED>
|
||
|
<!ATTLIST set sort CDATA "unsorted"> <!-- unsorted|natural|"comparator class" -->
|
||
|
<!ATTLIST set inverse (true|false) "false">
|
||
|
<!ATTLIST set mutable (true|false) "true">
|
||
|
<!ATTLIST set cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST set order-by CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST set where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST set batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST set outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST set fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST set persister CDATA #IMPLIED>
|
||
|
<!ATTLIST set collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST set check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST set optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST set node CDATA #IMPLIED>
|
||
|
<!ATTLIST set embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT bag (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
key,
|
||
|
(element|one-to-many|many-to-many|composite-element|many-to-any),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,
|
||
|
filter*
|
||
|
)>
|
||
|
<!ATTLIST bag name CDATA #REQUIRED>
|
||
|
<!ATTLIST bag access CDATA #IMPLIED>
|
||
|
<!ATTLIST bag table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST bag schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST bag catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST bag subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST bag lazy (true|false|extra) #IMPLIED>
|
||
|
<!ATTLIST bag inverse (true|false) "false">
|
||
|
<!ATTLIST bag mutable (true|false) "true">
|
||
|
<!ATTLIST bag cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST bag order-by CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST bag where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST bag batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST bag outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST bag fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST bag persister CDATA #IMPLIED>
|
||
|
<!ATTLIST bag collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST bag check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST bag optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST bag node CDATA #IMPLIED>
|
||
|
<!ATTLIST bag embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT idbag (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
collection-id,
|
||
|
key,
|
||
|
(element|many-to-many|composite-element|many-to-any),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,
|
||
|
filter*
|
||
|
)>
|
||
|
<!ATTLIST idbag name CDATA #REQUIRED>
|
||
|
<!ATTLIST idbag access CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST idbag schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST idbag catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST idbag subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag lazy (true|false|extra) #IMPLIED>
|
||
|
<!ATTLIST idbag mutable (true|false) "true">
|
||
|
<!ATTLIST idbag cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag order-by CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST idbag where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST idbag batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST idbag fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST idbag persister CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST idbag optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST idbag node CDATA #IMPLIED>
|
||
|
<!ATTLIST idbag embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT list (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
key,
|
||
|
(index|list-index),
|
||
|
(element|one-to-many|many-to-many|composite-element|many-to-any),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?,
|
||
|
filter*
|
||
|
)>
|
||
|
<!ATTLIST list name CDATA #REQUIRED>
|
||
|
<!ATTLIST list access CDATA #IMPLIED>
|
||
|
<!ATTLIST list table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST list schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST list catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST list subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST list lazy (true|false|extra) #IMPLIED>
|
||
|
<!ATTLIST list inverse (true|false) "false">
|
||
|
<!ATTLIST list mutable (true|false) "true">
|
||
|
<!ATTLIST list cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST list where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST list batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST list outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST list fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST list persister CDATA #IMPLIED>
|
||
|
<!ATTLIST list collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST list check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST list optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST list node CDATA #IMPLIED>
|
||
|
<!ATTLIST list embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT array (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
key,
|
||
|
(index|list-index),
|
||
|
(element|one-to-many|many-to-many|composite-element|many-to-any),
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?
|
||
|
)>
|
||
|
<!ATTLIST array name CDATA #REQUIRED>
|
||
|
<!ATTLIST array access CDATA #IMPLIED>
|
||
|
<!ATTLIST array table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST array schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST array catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST array subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST array inverse (true|false) "false">
|
||
|
<!ATTLIST array mutable (true|false) "true">
|
||
|
<!ATTLIST array element-class CDATA #IMPLIED>
|
||
|
<!ATTLIST array cascade CDATA #IMPLIED>
|
||
|
<!ATTLIST array where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST array batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST array outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST array fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST array persister CDATA #IMPLIED>
|
||
|
<!ATTLIST array collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST array check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST array optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST array node CDATA #IMPLIED>
|
||
|
<!ATTLIST array embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT primitive-array (
|
||
|
meta*,
|
||
|
subselect?,
|
||
|
cache?,
|
||
|
synchronize*,
|
||
|
comment?,
|
||
|
key,
|
||
|
(index|list-index),
|
||
|
element,
|
||
|
loader?,sql-insert?,sql-update?,sql-delete?,sql-delete-all?
|
||
|
)>
|
||
|
<!ATTLIST primitive-array name CDATA #REQUIRED>
|
||
|
<!ATTLIST primitive-array access CDATA #IMPLIED>
|
||
|
<!ATTLIST primitive-array table CDATA #IMPLIED> <!-- default: name -->
|
||
|
<!ATTLIST primitive-array schema CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST primitive-array catalog CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST primitive-array subselect CDATA #IMPLIED>
|
||
|
<!ATTLIST primitive-array mutable (true|false) "true">
|
||
|
<!ATTLIST primitive-array where CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST primitive-array batch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST primitive-array outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST primitive-array fetch (join|select|subselect) #IMPLIED>
|
||
|
<!ATTLIST primitive-array persister CDATA #IMPLIED>
|
||
|
<!ATTLIST primitive-array collection-type CDATA #IMPLIED>
|
||
|
<!ATTLIST primitive-array check CDATA #IMPLIED> <!-- default: none -->
|
||
|
<!ATTLIST primitive-array optimistic-lock (true|false) "true"> <!-- only supported for properties of a class (not component) -->
|
||
|
<!ATTLIST primitive-array node CDATA #IMPLIED>
|
||
|
<!ATTLIST primitive-array embed-xml (true|false) #IMPLIED>
|
||
|
|
||
|
<!-- Declares the element type of a collection of basic type -->
|
||
|
|
||
|
<!ELEMENT element ( (column|formula)*, type? )>
|
||
|
<!ATTLIST element column CDATA #IMPLIED>
|
||
|
<!ATTLIST element node CDATA #IMPLIED>
|
||
|
<!ATTLIST element formula CDATA #IMPLIED>
|
||
|
<!ATTLIST element type CDATA #IMPLIED>
|
||
|
<!ATTLIST element length CDATA #IMPLIED>
|
||
|
<!ATTLIST element precision CDATA #IMPLIED>
|
||
|
<!ATTLIST element scale CDATA #IMPLIED>
|
||
|
<!ATTLIST element not-null (true|false) "false">
|
||
|
<!ATTLIST element unique (true|false) "false">
|
||
|
|
||
|
<!-- One to many association. This tag declares the entity-class
|
||
|
element type of a collection and specifies a one-to-many relational model -->
|
||
|
|
||
|
<!ELEMENT one-to-many EMPTY>
|
||
|
<!ATTLIST one-to-many class CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-many not-found (exception|ignore) "exception">
|
||
|
<!ATTLIST one-to-many node CDATA #IMPLIED>
|
||
|
<!ATTLIST one-to-many embed-xml (true|false) #IMPLIED>
|
||
|
<!ATTLIST one-to-many entity-name CDATA #IMPLIED>
|
||
|
<!-- No column declaration attributes required in this case. The primary
|
||
|
key column of the associated class is already mapped elsewhere.-->
|
||
|
|
||
|
<!-- Many to many association. This tag declares the entity-class
|
||
|
element type of a collection and specifies a many-to-many relational model -->
|
||
|
|
||
|
<!ELEMENT many-to-many (meta*,(column|formula)*,filter*)>
|
||
|
<!ATTLIST many-to-many class CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many node CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many embed-xml (true|false) #IMPLIED>
|
||
|
<!ATTLIST many-to-many entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many column CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many formula CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many not-found (exception|ignore) "exception">
|
||
|
<!ATTLIST many-to-many outer-join (true|false|auto) #IMPLIED>
|
||
|
<!ATTLIST many-to-many fetch (join|select) #IMPLIED>
|
||
|
<!ATTLIST many-to-many lazy (false|proxy) #IMPLIED>
|
||
|
<!ATTLIST many-to-many foreign-key CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many unique (true|false) "false">
|
||
|
<!ATTLIST many-to-many where CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many order-by CDATA #IMPLIED>
|
||
|
<!ATTLIST many-to-many property-ref CDATA #IMPLIED>
|
||
|
|
||
|
<!-- A composite element allows a collection to hold instances of an arbitrary
|
||
|
class, without the requirement of joining to an entity table. Composite elements
|
||
|
have component semantics - no shared references and ad hoc null value semantics.
|
||
|
Composite elements may not hold nested collections. -->
|
||
|
|
||
|
<!ELEMENT composite-element (
|
||
|
(meta*),
|
||
|
parent?,
|
||
|
tuplizer*,
|
||
|
(property|many-to-one|any|nested-composite-element)*
|
||
|
)>
|
||
|
<!ATTLIST composite-element class CDATA #REQUIRED>
|
||
|
<!ATTLIST composite-element node CDATA #IMPLIED>
|
||
|
|
||
|
<!ELEMENT nested-composite-element (
|
||
|
parent?,
|
||
|
tuplizer*,
|
||
|
(property|many-to-one|any|nested-composite-element)*
|
||
|
)>
|
||
|
<!ATTLIST nested-composite-element class CDATA #REQUIRED>
|
||
|
<!ATTLIST nested-composite-element name CDATA #REQUIRED>
|
||
|
<!ATTLIST nested-composite-element access CDATA #IMPLIED>
|
||
|
<!ATTLIST nested-composite-element node CDATA #IMPLIED>
|
||
|
|
||
|
<!-- Declares the column name of a foreign key. -->
|
||
|
|
||
|
<!ELEMENT key (column*)>
|
||
|
<!ATTLIST key column CDATA #IMPLIED>
|
||
|
<!ATTLIST key property-ref CDATA #IMPLIED>
|
||
|
<!ATTLIST key foreign-key CDATA #IMPLIED>
|
||
|
<!ATTLIST key on-delete (cascade|noaction) "noaction">
|
||
|
<!ATTLIST key not-null (true|false) #IMPLIED>
|
||
|
<!ATTLIST key update (true|false) #IMPLIED>
|
||
|
<!ATTLIST key unique (true|false) #IMPLIED>
|
||
|
|
||
|
<!-- Declares the type and column mapping for a collection index (array or
|
||
|
list index, or key of a map). -->
|
||
|
|
||
|
<!ELEMENT list-index (column?)>
|
||
|
<!ATTLIST list-index column CDATA #IMPLIED>
|
||
|
<!ATTLIST list-index base CDATA "0">
|
||
|
|
||
|
<!ELEMENT map-key ((column|formula)*,type?)>
|
||
|
<!ATTLIST map-key column CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key formula CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key type CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key length CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key node CDATA #IMPLIED>
|
||
|
|
||
|
<!ELEMENT index (column*)>
|
||
|
<!ATTLIST index column CDATA #IMPLIED>
|
||
|
<!ATTLIST index type CDATA #IMPLIED> <!-- required for maps -->
|
||
|
<!ATTLIST index length CDATA #IMPLIED>
|
||
|
|
||
|
<!-- Many to many association mapped to the key of a map. ie. a map keyed
|
||
|
on entities. -->
|
||
|
|
||
|
<!ELEMENT map-key-many-to-many ((column|formula)*)>
|
||
|
<!ATTLIST map-key-many-to-many class CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key-many-to-many entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key-many-to-many column CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key-many-to-many formula CDATA #IMPLIED>
|
||
|
<!ATTLIST map-key-many-to-many foreign-key CDATA #IMPLIED>
|
||
|
|
||
|
<!ELEMENT index-many-to-many (column*)>
|
||
|
<!ATTLIST index-many-to-many class CDATA #REQUIRED>
|
||
|
<!ATTLIST index-many-to-many entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST index-many-to-many column CDATA #IMPLIED>
|
||
|
<!ATTLIST index-many-to-many foreign-key CDATA #IMPLIED>
|
||
|
|
||
|
<!-- Composite index of a map ie. a map keyed on components. -->
|
||
|
|
||
|
<!ELEMENT composite-map-key ( (key-property|key-many-to-one)+ )>
|
||
|
<!ATTLIST composite-map-key class CDATA #REQUIRED>
|
||
|
|
||
|
<!ELEMENT composite-index ( (key-property|key-many-to-one)+ )>
|
||
|
<!ATTLIST composite-index class CDATA #REQUIRED>
|
||
|
|
||
|
<!-- A "many to any" defines a polymorphic association to any table
|
||
|
with the given identifier type. The first listed column is a VARCHAR column
|
||
|
holding the name of the class (for that row). -->
|
||
|
|
||
|
<!ELEMENT many-to-any (meta-value*,column, column+)>
|
||
|
<!ATTLIST many-to-any id-type CDATA #REQUIRED>
|
||
|
<!ATTLIST many-to-any meta-type CDATA #IMPLIED> <!--- default: Hibernate.CLASS -->
|
||
|
|
||
|
<!ELEMENT index-many-to-any (column, column+)>
|
||
|
<!ATTLIST index-many-to-any id-type CDATA #REQUIRED>
|
||
|
<!ATTLIST index-many-to-any meta-type CDATA #IMPLIED> <!--- default: Hibernate.CLASS -->
|
||
|
|
||
|
<!ELEMENT collection-id (meta*, column*, generator)>
|
||
|
<!ATTLIST collection-id column CDATA #REQUIRED>
|
||
|
<!ATTLIST collection-id type CDATA #REQUIRED>
|
||
|
<!ATTLIST collection-id length CDATA #IMPLIED>
|
||
|
|
||
|
<!-- Generators generate unique identifiers. The class attribute specifies a Java
|
||
|
class implementing an id generation algorithm. -->
|
||
|
|
||
|
<!ELEMENT generator (param*)>
|
||
|
<!ATTLIST generator class CDATA #REQUIRED>
|
||
|
<!ELEMENT param (#PCDATA)>
|
||
|
<!ATTLIST param name CDATA #REQUIRED>
|
||
|
|
||
|
<!-- The column element is an alternative to column attributes and required for
|
||
|
mapping associations to classes with composite ids. -->
|
||
|
|
||
|
<!ELEMENT column (comment?)>
|
||
|
<!ATTLIST column name CDATA #REQUIRED>
|
||
|
<!ATTLIST column length CDATA #IMPLIED> <!-- default: 255 -->
|
||
|
<!ATTLIST column precision CDATA #IMPLIED>
|
||
|
<!ATTLIST column scale CDATA #IMPLIED>
|
||
|
<!ATTLIST column not-null (true|false) #IMPLIED> <!-- default: false (except for id properties) -->
|
||
|
<!ATTLIST column unique (true|false) #IMPLIED> <!-- default: false (except for id properties) -->
|
||
|
<!ATTLIST column unique-key CDATA #IMPLIED> <!-- default: no unique key -->
|
||
|
<!ATTLIST column sql-type CDATA #IMPLIED> <!-- override default column type for hibernate type -->
|
||
|
<!ATTLIST column index CDATA #IMPLIED>
|
||
|
<!ATTLIST column check CDATA #IMPLIED> <!-- default: no check constraint -->
|
||
|
<!ATTLIST column default CDATA #IMPLIED> <!-- default: no default value -->
|
||
|
<!ATTLIST column read CDATA #IMPLIED> <!-- default: column name -->
|
||
|
<!ATTLIST column write CDATA #IMPLIED> <!-- default: parameter placeholder ('?') -->
|
||
|
|
||
|
<!-- The formula and subselect elements allow us to map derived properties and
|
||
|
entities. -->
|
||
|
|
||
|
<!ELEMENT formula (#PCDATA)>
|
||
|
<!ELEMENT subselect (#PCDATA)>
|
||
|
|
||
|
<!-- The cache element enables caching of an entity class. -->
|
||
|
<!ELEMENT cache EMPTY>
|
||
|
<!ATTLIST cache usage (read-only|read-write|nonstrict-read-write|transactional) #REQUIRED>
|
||
|
<!ATTLIST cache region CDATA #IMPLIED> <!-- default: class or collection role name -->
|
||
|
<!ATTLIST cache include (all|non-lazy) "all">
|
||
|
|
||
|
<!-- The comment element allows definition of a database table or column comment. -->
|
||
|
|
||
|
<!ELEMENT comment (#PCDATA)>
|
||
|
|
||
|
<!-- The loader element allows specification of a named query to be used for fetching
|
||
|
an entity or collection -->
|
||
|
|
||
|
<!ELEMENT loader EMPTY>
|
||
|
<!ATTLIST loader query-ref CDATA #REQUIRED>
|
||
|
|
||
|
<!-- The query element declares a named Hibernate query string -->
|
||
|
|
||
|
<!ELEMENT query (#PCDATA|query-param)*>
|
||
|
<!ATTLIST query name CDATA #REQUIRED>
|
||
|
<!ATTLIST query flush-mode (auto|never|always) #IMPLIED>
|
||
|
<!ATTLIST query cacheable (true|false) "false">
|
||
|
<!ATTLIST query cache-region CDATA #IMPLIED>
|
||
|
<!ATTLIST query fetch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST query timeout CDATA #IMPLIED>
|
||
|
<!ATTLIST query cache-mode (get|ignore|normal|put|refresh) #IMPLIED>
|
||
|
<!ATTLIST query read-only (true|false) #IMPLIED>
|
||
|
<!ATTLIST query comment CDATA #IMPLIED>
|
||
|
|
||
|
<!-- The sql-query element declares a named SQL query string -->
|
||
|
|
||
|
<!ELEMENT sql-query (#PCDATA|return-scalar|return|return-join|load-collection|synchronize|query-param)*>
|
||
|
<!ATTLIST sql-query name CDATA #REQUIRED>
|
||
|
<!ATTLIST sql-query resultset-ref CDATA #IMPLIED>
|
||
|
<!ATTLIST sql-query flush-mode (auto|never|always) #IMPLIED>
|
||
|
<!ATTLIST sql-query cacheable (true|false) "false">
|
||
|
<!ATTLIST sql-query cache-region CDATA #IMPLIED>
|
||
|
<!ATTLIST sql-query fetch-size CDATA #IMPLIED>
|
||
|
<!ATTLIST sql-query timeout CDATA #IMPLIED>
|
||
|
<!ATTLIST sql-query cache-mode (get|ignore|normal|put|refresh) #IMPLIED>
|
||
|
<!ATTLIST sql-query read-only (true|false) #IMPLIED>
|
||
|
<!ATTLIST sql-query comment CDATA #IMPLIED>
|
||
|
<!ATTLIST sql-query callable (true|false) "false">
|
||
|
|
||
|
<!-- The query-param element is used only by tools that generate
|
||
|
finder methods for named queries -->
|
||
|
|
||
|
<!ELEMENT query-param EMPTY>
|
||
|
<!ATTLIST query-param name CDATA #REQUIRED>
|
||
|
<!ATTLIST query-param type CDATA #REQUIRED>
|
||
|
|
||
|
<!-- The resultset element declares a named resultset mapping definition for SQL queries -->
|
||
|
<!ELEMENT resultset (return-scalar|return|return-join|load-collection)*>
|
||
|
<!ATTLIST resultset name CDATA #REQUIRED>
|
||
|
|
||
|
<!--
|
||
|
Defines a return component for a sql-query. Alias refers to the alias
|
||
|
used in the actual sql query; lock-mode specifies the locking to be applied
|
||
|
when the query is executed. The class, collection, and role attributes are mutually exclusive;
|
||
|
class refers to the class name of a "root entity" in the object result; collection refers
|
||
|
to a collection of a given class and is used to define custom sql to load that owned collection
|
||
|
and takes the form "ClassName.propertyName"; role refers to the property path for an eager fetch
|
||
|
and takes the form "owningAlias.propertyName"
|
||
|
-->
|
||
|
<!ELEMENT return (return-discriminator?,return-property)*>
|
||
|
<!ATTLIST return alias CDATA #IMPLIED>
|
||
|
<!ATTLIST return entity-name CDATA #IMPLIED>
|
||
|
<!ATTLIST return class CDATA #IMPLIED>
|
||
|
<!ATTLIST return lock-mode (none|read|upgrade|upgrade-nowait|upgrade-skiplocked|write) "read">
|
||
|
|
||
|
<!ELEMENT return-property (return-column*)>
|
||
|
<!ATTLIST return-property name CDATA #REQUIRED>
|
||
|
<!ATTLIST return-property column CDATA #IMPLIED>
|
||
|
|
||
|
<!ELEMENT return-column EMPTY>
|
||
|
<!ATTLIST return-column name CDATA #REQUIRED>
|
||
|
|
||
|
<!ELEMENT return-discriminator EMPTY>
|
||
|
<!ATTLIST return-discriminator column CDATA #REQUIRED>
|
||
|
|
||
|
<!ELEMENT return-join (return-property)*>
|
||
|
<!ATTLIST return-join alias CDATA #REQUIRED>
|
||
|
<!ATTLIST return-join property CDATA #REQUIRED>
|
||
|
<!ATTLIST return-join lock-mode (none|read|upgrade|upgrade-nowait|upgrade-skiplocked|write) "read">
|
||
|
|
||
|
<!ELEMENT load-collection (return-property)*>
|
||
|
<!ATTLIST load-collection alias CDATA #REQUIRED>
|
||
|
<!ATTLIST load-collection role CDATA #REQUIRED>
|
||
|
<!ATTLIST load-collection lock-mode (none|read|upgrade|upgrade-nowait|upgrade-skiplocked|write) "read">
|
||
|
|
||
|
<!ELEMENT return-scalar EMPTY>
|
||
|
<!ATTLIST return-scalar column CDATA #REQUIRED>
|
||
|
<!ATTLIST return-scalar type CDATA #IMPLIED>
|
||
|
|
||
|
<!ELEMENT synchronize EMPTY>
|
||
|
<!ATTLIST synchronize table CDATA #REQUIRED>
|
||
|
|
||
|
<!-- custom sql operations -->
|
||
|
<!ELEMENT sql-insert (#PCDATA)>
|
||
|
<!ATTLIST sql-insert callable (true|false) "false">
|
||
|
<!ATTLIST sql-insert check (none|rowcount|param) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT sql-update (#PCDATA)>
|
||
|
<!ATTLIST sql-update callable (true|false) "false">
|
||
|
<!ATTLIST sql-update check (none|rowcount|param) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT sql-delete (#PCDATA)>
|
||
|
<!ATTLIST sql-delete callable (true|false) "false">
|
||
|
<!ATTLIST sql-delete check (none|rowcount|param) #IMPLIED>
|
||
|
|
||
|
<!ELEMENT sql-delete-all (#PCDATA)>
|
||
|
<!ATTLIST sql-delete-all callable (true|false) "false">
|
||
|
<!ATTLIST sql-delete-all check (none|rowcount|param) #IMPLIED>
|
||
|
|
||
|
<!--
|
||
|
Element for defining "auxiliary" database objects. Must be one of two forms:
|
||
|
|
||
|
#1 :
|
||
|
<database-object>
|
||
|
<definition class="CustomClassExtendingAuxiliaryObject"/>
|
||
|
</database-object>
|
||
|
|
||
|
#2 :
|
||
|
<database-object>
|
||
|
<create>CREATE OR REPLACE ....</create>
|
||
|
<drop>DROP ....</drop>
|
||
|
</database-object>
|
||
|
-->
|
||
|
<!ELEMENT database-object ( (definition|(create,drop)), dialect-scope* )>
|
||
|
|
||
|
<!ELEMENT definition EMPTY>
|
||
|
<!ATTLIST definition class CDATA #REQUIRED>
|
||
|
|
||
|
<!ELEMENT create (#PCDATA)>
|
||
|
<!ELEMENT drop (#PCDATA)>
|
||
|
|
||
|
<!--
|
||
|
dialect-scope element allows scoping auxiliary-objects to a particular
|
||
|
Hibernate dialect implementation.
|
||
|
-->
|
||
|
<!ELEMENT dialect-scope (#PCDATA)>
|
||
|
<!ATTLIST dialect-scope name CDATA #REQUIRED>
|
||
|
|