Hibernate example source code file (collection_mapping.po)

This example Hibernate source code file (collection_mapping.po) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

cdata, cdata, child, entity\n, hibernate, hibernate, parent, set, sql, tag, tag, the, the, this

The Hibernate collection_mapping.po source code

# translation of Collection_Mapping.po to
# Xi Huang <xhuang@redhat.com>, 2006.
# Xi HUANG <xhuang@redhat.com>, 2007.
msgid ""
msgstr ""
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-07-20 21:02+0000\n"
"PO-Revision-Date: 2010-03-15 08:59+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team:  <en@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.11.4\n"

#. Tag: title
#: collection_mapping.xml:31
#, no-c-format
msgid "Collection mapping"
msgstr "集合映射（Collection mappings）"

#. Tag: title
#: collection_mapping.xml:34
#, no-c-format
msgid "Persistent collections"
msgstr "持久化集合类（Persistent collections）"

#. Tag: para
#: collection_mapping.xml:36
#, fuzzy, no-c-format
msgid ""
"Naturally Hibernate also allows to persist collections. These persistent "
"collections can contain almost any other Hibernate type, including: basic "
"types, custom types, components and references to other entities. The "
"distinction between value and reference semantics is in this context very "
"important. An object in a collection might be handled with \"value\" "
"semantics (its life cycle fully depends on the collection owner), or it "
"might be a reference to another entity with its own life cycle. In the "
"latter case, only the \"link\" between the two objects is considered to be a "
"state held by the collection."
msgstr ""
"集合几乎可以包含任何其他的 Hibernate 类型，包括所有的基本类型、自定义类型、组"
"件，当然还有对其他实体的引用。存在一个重要的区别：位于集合中的对象可能是根"
"据“值”语义来操作（其声明周期完全依赖于集合持有者），或者它可能是指向另一个实"
"体的引用，具有其自己的生命周期。在后者的情况下，被作为集合持有的状态考虑的，"
"只有两个对象之间的“连接”。 "

#. Tag: para
#: collection_mapping.xml:46
#, fuzzy, no-c-format
msgid ""
"As a requirement persistent collection-valued fields must be declared as an "
"interface type (see <xref linkend=\"example.collection.mapping.annotations\"/"
">). The actual interface might be <literal>java.util.Set, "
"<literal>java.util.Collection, java.util.List, "
"<literal>java.util.Map, java.util.SortedSet, "
"<literal>java.util.SortedMap or anything you like (\"anything you "
"like\" means you will have to write an implementation of <literal>org."
"hibernate.usertype.UserCollectionType</literal>)."
msgstr ""
"实际的接口可能是 <literal>java.util.Set、java.util."
"Collection</literal>、java.util.List、java.util."
"Map</literal>、java.util.SortedSet、java.util."
"SortedMap</literal> 或者任何你喜欢的类型（\"任何你喜欢的类型\" 代表你需要编"
"写 <literal>org.hibernate.usertype.UserCollectionType 的实现）。"

#. Tag: para
#: collection_mapping.xml:57
#, fuzzy, no-c-format
msgid ""
"Notice how in <xref linkend=\"example.collection.mapping.annotations\"/> the "
"instance variable <literal>parts was initialized with an instance "
"of <literal>HashSet. This is the best way to initialize collection "
"valued properties of newly instantiated (non-persistent) instances. When you "
"make the instance persistent, by calling <literal>persist(), "
"Hibernate will actually replace the <literal>HashSet with an "
"instance of Hibernate's own implementation of <literal>Set. Be "
"aware of the following error:"
msgstr ""
"注意我们是如何用一个 <literal>HashSet 实例来初始化实例变量的。这是"
"用于初始化新创建（尚未持久化）的类实例中集合值属性的最佳方法。当你持久化这个"
"实例时 — 比如通过调用 <literal>persist() — Hibernate 会自动把 "
"<literal>HashSet 替换为 Hibernate 自己的 Set 实"
"现。注意下面的错误："

#. Tag: title
#: collection_mapping.xml:68
#, no-c-format
msgid "Hibernate uses its own collection implementations"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:70
#, fuzzy, no-c-format
msgid ""
"Cat cat = new DomesticCat();\n"
"Cat kitten = new DomesticCat();\n"
"....\n"
"Set kittens = new HashSet();\n"
"kittens.add(kitten);\n"
"cat.setKittens(kittens);\n"
"session.persist(cat);\n"
"\n"
"kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
"(HashSet) cat.getKittens(); // Error!"
msgstr ""
"<![CDATA[Cat cat = new DomesticCat();\n"
"Cat kitten = new DomesticCat();\n"
"....\n"
"Set kittens = new HashSet();\n"
"kittens.add(kitten);\n"
"cat.setKittens(kittens);\n"
"session.persist(cat);\n"
"kittens = cat.getKittens(); // Okay, kittens collection is a Set\n"
"(HashSet) cat.getKittens(); // Error!]]>"

#. Tag: para
#: collection_mapping.xml:73
#, no-c-format
msgid ""
"The persistent collections injected by Hibernate behave like "
"<literal>HashMap, HashSet, TreeMapTreeSet or ArrayList, "
"depending on the interface type."
msgstr ""
"根据不同的接口类型，被 Hibernate 注射的持久化集合类的表现类似 "
"<literal>HashMap、HashSet、TreeMapTreeSet 或 ArrayList。"

#. Tag: para
#: collection_mapping.xml:78
#, no-c-format
msgid ""
"Collections instances have the usual behavior of value types. They are "
"automatically persisted when referenced by a persistent object and are "
"automatically deleted when unreferenced. If a collection is passed from one "
"persistent object to another, its elements might be moved from one table to "
"another. Two entities cannot share a reference to the same collection "
"instance. Due to the underlying relational model, collection-valued "
"properties do not support null value semantics. Hibernate does not "
"distinguish between a null collection reference and an empty collection."
msgstr ""
"集合类实例具有值类型的通常行为。当被持久化对象引用后，他们会自动被持久化，当"
"不再被引用后，自动被删除。假若实例被从一个持久化对象传递到另一个，它的元素可"
"能从一个表转移到另一个表。两个实体不能共享同一个集合类实例的引用。因为底层关"
"系数据库模型的原因，集合值属性无法支持空值语义；Hibernate 对空的集合引用和空"
"集合不加区别。 "

#. Tag: para
#: collection_mapping.xml:89
#, fuzzy, no-c-format
msgid ""
"Use persistent collections the same way you use ordinary Java collections. "
"However, ensure you understand the semantics of bidirectional associations "
"(see <xref linkend=\"collections-bidirectional\"/>)."
msgstr ""
"你不需要过多的为此担心。就如同你平时使用普通的 Java 集合类一样来使用持久化集"
"合类。只是要确认你理解了双向关联的语义（后文将进行讨论）。"

#. Tag: title
#: collection_mapping.xml:97
#, fuzzy, no-c-format
msgid "How to map collections"
msgstr "有序集合（Sorted collections）"

#. Tag: para
#: collection_mapping.xml:99
#, no-c-format
msgid ""
"Using annotations you can map <classname>Collections, "
"<classname>Lists, Maps and "
"<classname>Sets of associated entities using @OneToMany and "
"@ManyToMany. For collections of a basic or embeddable type use "
"@ElementCollection. In the simplest case a collection mapping looks like "
"this:"
msgstr ""

#. Tag: title
#: collection_mapping.xml:107
#, no-c-format
msgid "Collection mapping using @OneToMany and @JoinColumn"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:109
#, fuzzy, no-c-format
msgid ""
"@Entity\n"
"public class Product {\n"
"\n"
"    private String serialNumber;\n"
"    private Set<Part> parts = new HashSet<Part>();\n"
"\n"
"    @Id\n"
"    public String getSerialNumber() { return serialNumber; }\n"
"    void setSerialNumber(String sn) { serialNumber = sn; }\n"
"   \n"
"    @OneToMany\n"
"    @JoinColumn(name=\"PART_ID\")\n"
"    public Set<Part> getParts() { return parts; }\n"
"    void setParts(Set parts) { this.parts = parts; }\n"
"}\n"
"\n"
"\n"
"@Entity\n"
"public class Part {\n"
"   ...\n"
"}"
msgstr ""
"<![CDATA[public class Product {\n"
"    private String serialNumber;\n"
"    private Set parts = new HashSet();\n"
"    \n"
"    public Set getParts() { return parts; }\n"
"    void setParts(Set parts) { this.parts = parts; }\n"
"    public String getSerialNumber() { return serialNumber; }\n"
"    void setSerialNumber(String sn) { serialNumber = sn; }\n"
"}]]>"

#. Tag: para
#: collection_mapping.xml:112
#, no-c-format
msgid ""
"Product describes a unidirectional relationship with Part using the join "
"column PART_ID. In this unidirectional one to many scenario you can also use "
"a join table as seen in <xref linkend=\"example-one-to-many-with-join-table"
"\"/>."
msgstr ""

#. Tag: title
#: collection_mapping.xml:118
#, no-c-format
msgid "Collection mapping using @OneToMany and @JoinTable"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:121
#, no-c-format
msgid ""
"@Entity\n"
"public class Product {\n"
"\n"
"    private String serialNumber;\n"
"    private Set<Part> parts = new HashSet<Part>();\n"
"\n"
"    @Id\n"
"    public String getSerialNumber() { return serialNumber; }\n"
"    void setSerialNumber(String sn) { serialNumber = sn; }\n"
"   \n"
"    @OneToMany\n"
"    @JoinTable(\n"
"            name=\"PRODUCT_PARTS\",\n"
"            joinColumns = @JoinColumn( name=\"PRODUCT_ID\"),\n"
"            inverseJoinColumns = @JoinColumn( name=\"PART_ID\")\n"
"    )\n"
"    public Set<Part> getParts() { return parts; }\n"
"    void setParts(Set parts) { this.parts = parts; }\n"
"}\n"
"\n"
"\n"
"@Entity\n"
"public class Part {\n"
"   ...\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:124
#, no-c-format
msgid ""
"Without describing any physical mapping (no <classname>@JoinColumn@JoinTable), a unidirectional one to "
"many with join table is used. The table name is the concatenation of the "
"owner table name, _, and the other side table name. The foreign key name(s) "
"referencing the owner table is the concatenation of the owner table, _, and "
"the owner primary key column(s) name. The foreign key name(s) referencing "
"the other side is the concatenation of the owner property name, _, and the "
"other side primary key column(s) name. A unique constraint is added to the "
"foreign key referencing the other side table to reflect the one to many."
msgstr ""

#. Tag: para
#: collection_mapping.xml:135
#, fuzzy, no-c-format
msgid ""
"Lets have a look now how collections are mapped using Hibernate mapping "
"files. In this case the first step is to chose the right mapping element. It "
"depends on the type of interface. For example, a <literal><set>SetSet 类型的属性。 "

#. Tag: title
#: collection_mapping.xml:142
#, no-c-format
msgid "Mapping a Set using <set>"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:144
#, fuzzy, no-c-format
msgid ""
"<class name=\"Product\">\n"
"    <id name=\"serialNumber\" column=\"productSerialNumber\"/>\n"
"    <set name=\"parts\">\n"
"        <key column=\"productSerialNumber\" not-null=\"true\"/>\n"
"        <one-to-many class=\"Part\"/>\n"
"    </set>\n"
"</class>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:147
#, fuzzy, no-c-format
msgid ""
"In <xref linkend=\"example.collections.set\"/> a one-to-many "
"association</emphasis> links the Product and "
"<literal>Part entities. This association requires the existence of "
"a foreign key column and possibly an index column to the <literal>Part 到 Part 的关联需要关键字"
"字段，可能还有一个索引字段指向 <literal>Part 所对应的表。"
"<literal><one-to-many> 标记指明了一个一对多的关联。 "

#. Tag: para
#: collection_mapping.xml:156
#, no-c-format
msgid ""
"An instance of the contained entity class cannot belong to more than one "
"instance of the collection."
msgstr "一个被包含的实体的实例只能被包含在一个集合的实例中。"

#. Tag: para
#: collection_mapping.xml:161
#, no-c-format
msgid ""
"An instance of the contained entity class cannot appear at more than one "
"value of the collection index."
msgstr "一个被包含的实体的实例只能对应于集合索引的一个值中。"

#. Tag: para
#: collection_mapping.xml:166
#, no-c-format
msgid ""
"Looking closer at the used <literal><one-to-many> tag we see "
"that it has the following options."
msgstr ""

#. Tag: title
#: collection_mapping.xml:170
#, no-c-format
msgid "options of <one-to-many> element"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:181
#, fuzzy, no-c-format
msgid ""
"<one-to-many\n"
"        class=\"ClassName\"\n"
"        not-found=\"ignore|exception\"\n"
"        entity-name=\"EntityName\"\n"
"        node=\"element-name\"\n"
"        embed-xml=\"true|false\"\n"
"    />"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:185
#, no-c-format
msgid "<literal>class (required): the name of the associated class."
msgstr "<literal>class（必需）：被关联类的名称。 "

#. Tag: para
#: collection_mapping.xml:190
#, no-c-format
msgid ""
"<literal>not-found (optional - defaults to exception will treat a missing row as a null "
"association."
msgstr ""
"<literal>not-found（可选 - 默认为exception）：指"
"明若缓存的标示值关联的行缺失，该如何处理：<literal>ignore 会把缺失"
"的行作为一个空关联处理。 "

#. Tag: para
#: collection_mapping.xml:198
#, no-c-format
msgid ""
"<literal>entity-name (optional): the entity name of the associated "
"class, as an alternative to <literal>class."
msgstr ""
"<literal>entity-name（可选）：被关联的类的实体名，作为 "
"<literal>class 的替代。 "

#. Tag: para
#: collection_mapping.xml:206
#, no-c-format
msgid ""
"The <literal><one-to-many> element does not need to declare "
"any columns. Nor is it necessary to specify the <literal>table "
"name anywhere."
msgstr ""
"注意：<literal><one-to-many> 元素不需要定义任何字段。也不需要"
"指定表名。 "

#. Tag: para
#: collection_mapping.xml:211
#, fuzzy, no-c-format
msgid ""
"If the foreign key column of a <literal><one-to-many> "
"association is declared <literal>NOT NULL, you must declare the "
"<literal><key> mapping not-null=\"true\" "
"or <emphasis>use a bidirectional association with the collection "
"mapping marked <literal>inverse=\"true\". See ：如果一对多关联中的外键字段"
"定义成 <literal>NOT NULL，你必须把 <key> "
"映射声明为 <literal>not-null=\"true\"，或者使用双向关联inverse=\"true\"。参阅本章后面关于双向"
"关联的讨论。 "

#. Tag: para
#: collection_mapping.xml:221
#, fuzzy, no-c-format
msgid ""
"Apart from the <literal><set> tag as shown in <list><map>, <bag>, "
"<literal><array> and <primitive-array><map> element is "
"representative:"
msgstr ""
"除了 <literal><set>，还有<list>，"
"<literal><map>，<bag>，<"
"array></literal> 和 <primitive-array> 映射元素。"
"<literal><map> 具有代表性："

#. Tag: title
#: collection_mapping.xml:229
#, no-c-format
msgid "Elements of the <map> mapping"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:262
#, fuzzy, no-c-format
msgid ""
"<map\n"
"    name=\"propertyName\"\n"
"    table=\"table_name\"\n"
"    schema=\"schema_name\"\n"
"    lazy=\"true|extra|false\"\n"
"    inverse=\"true|false\"\n"
"    cascade=\"all|none|save-update|delete|all-delete-orphan|delete-orphan\"\n"
"    sort=\"unsorted|natural|comparatorClass\"\n"
"    order-by=\"column_name asc|desc\"\n"
"    where=\"arbitrary sql where condition\"\n"
"    fetch=\"join|select|subselect\"\n"
"    batch-size=\"N\"\n"
"    access=\"field|property|ClassName\"\n"
"    optimistic-lock=\"true|false\"\n"
"    mutable=\"true|false\"\n"
"    node=\"element-name|.\"\n"
"    embed-xml=\"true|false\"\n"
">\n"
"\n"
"    <key .... />\n"
"    <map-key .... />\n"
"    <element .... />\n"
"</map>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:266
#, no-c-format
msgid "<literal>name: the collection property name"
msgstr "<literal>name：集合属性的名称"

#. Tag: para
#: collection_mapping.xml:270
#, no-c-format
msgid ""
"<literal>table (optional - defaults to property name): the name of "
"the collection table. It is not used for one-to-many associations."
msgstr ""
"<literal>table（可选——默认为属性的名称）这个集合表的名称（不能在一"
"对多的关联关系中使用）。"

#. Tag: para
#: collection_mapping.xml:276
#, no-c-format
msgid ""
"<literal>schema (optional): the name of a table schema to override "
"the schema declared on the root element"
msgstr ""
"<literal>schema（可选）：表的 schema 的名称，他将覆盖在根元素中定义"
"的 schema"

#. Tag: para
#: collection_mapping.xml:281
#, no-c-format
msgid ""
"<literal>lazy (optional - defaults to true): "
"disables lazy fetching and specifies that the association is always eagerly "
"fetched. It can also be used to enable \"extra-lazy\" fetching where most "
"operations do not initialize the collection. This is suitable for large "
"collections."
msgstr ""
"<literal>lazy（可选--默认为 true）可以用来关闭延迟加载（false）：指"
"定一直使用预先抓取，或者打开 \"extra-lazy\" 抓取，此时大多数操作不会初始化集"
"合类（适用于非常大的集合）。"

#. Tag: para
#: collection_mapping.xml:290
#, no-c-format
msgid ""
"<literal>inverse (optional - defaults to false（可选 — 默认为 false）标记这个"
"集合作为双向关联关系中的方向一端。 "

#. Tag: para
#: collection_mapping.xml:296
#, no-c-format
msgid ""
"<literal>cascade (optional - defaults to none): "
"enables operations to cascade to child entities."
msgstr ""
"<literal>cascade（可选 — 默认为 none）让操作级联"
"到子实体。"

#. Tag: para
#: collection_mapping.xml:302
#, no-c-format
msgid ""
"<literal>sort (optional): specifies a sorted collection with "
"<literal>natural sort order or a given comparator class."
msgstr ""
"<literal>sort（可选）指定集合的排序顺序，其可以为自然的"
"（<literal>natural）或者给定一个用来比较的类。 "

#. Tag: para
#: collection_mapping.xml:308
#, fuzzy, no-c-format
msgid ""
"<literal>order-by (optional): specifies a table column or columns "
"that define the iteration order of the <literal>Map, Setasc or "
"<literal>desc."
msgstr ""
"<literal>order-by（可选，仅用于 jdk1.4）：指定表的字段（一个或几"
"个）再加上 asc 或者 desc（可选），定义 Map、Set 和 Bag 的迭代顺序。"

#. Tag: para
#: collection_mapping.xml:316
#, no-c-format
msgid ""
"<literal>where (optional): specifies an arbitrary SQL "
"<literal>WHERE condition that is used when retrieving or removing "
"the collection. This is useful if the collection needs to contain only a "
"subset of the available data."
msgstr ""
"<literal>where（可选）：指定任意的 SQL where 条件，该条件将在重新载"
"入或者删除这个集合时使用（当集合中的数据仅仅是所有可用数据的一个子集时这个条"
"件非常有用）。"

#. Tag: para
#: collection_mapping.xml:324
#, no-c-format
msgid ""
"<literal>fetch (optional, defaults to select): "
"chooses between outer-join fetching, fetching by sequential select, and "
"fetching by sequential subselect."
msgstr ""
"<literal>fetch（可选，默认为 select）：用于在外"
"连接抓取、通过后续 select 抓取和通过后续 subselect 抓取之间选择。"

#. Tag: para
#: collection_mapping.xml:331
#, no-c-format
msgid ""
"<literal>batch-size (optional, defaults to 1): "
"specifies a \"batch size\" for lazily fetching instances of this collection."
msgstr ""
"<literal>batch-size（可选，默认为 1）：指定通过"
"延迟加载取得集合实例的批处理块大小（\"batch size\"）。"

#. Tag: para
#: collection_mapping.xml:337
#, no-c-format
msgid ""
"<literal>access (optional - defaults to property（可选-默认为属性 property）：Hibernate 取得集合属性"
"值时使用的策略。"

#. Tag: para
#: collection_mapping.xml:343
#, no-c-format
msgid ""
"<literal>optimistic-lock (optional - defaults to true（可选 - 默认为 true）：对集合的"
"状态的改变会是否导致其所属的实体的版本增长（对一对多关联来说，关闭这个属性常"
"常是有理的）。"

#. Tag: para
#: collection_mapping.xml:351
#, no-c-format
msgid ""
"<literal>mutable (optional - defaults to true): "
"a value of <literal>false specifies that the elements of the "
"collection never change. This allows for minor performance optimization in "
"some cases."
msgstr ""
"<literal>mutable（可变）（可选 — 默认为 true）："
"若值为 <literal>false，表明集合中的元素不会改变（在某些情况下可以进"
"行一些小的性能优化）。 "

#. Tag: para
#: collection_mapping.xml:360
#, no-c-format
msgid ""
"After exploring the basic mapping of collections in the preceding paragraphs "
"we will now focus details like physical mapping considerations, indexed "
"collections and collections of value types."
msgstr ""

#. Tag: title
#: collection_mapping.xml:365
#, no-c-format
msgid "Collection foreign keys"
msgstr "集合外键（Collection foreign keys）"

#. Tag: para
#: collection_mapping.xml:367
#, fuzzy, no-c-format
msgid ""
"On the database level collection instances are distinguished by the foreign "
"key of the entity that owns the collection. This foreign key is referred to "
"as the <emphasis>collection key column, or columns, of the "
"collection table. The collection key column is mapped by the "
"<literal>@JoinColumn annotation respectively the <"
"key></literal> XML element."
msgstr ""
"集合实例在数据库中依靠持有集合的实体的外键加以辨别。此外键作为<emphasis>集合"
"关键字段（collection key column）</emphasis>（或多个字段）加以引用。集合关键"
"字段通过 <literal><key> 元素映射。 "

#. Tag: para
#: collection_mapping.xml:374
#, fuzzy, no-c-format
msgid ""
"There can be a nullability constraint on the foreign key column. For most "
"collections, this is implied. For unidirectional one-to-many associations, "
"the foreign key column is nullable by default, so you may need to specify"
msgstr ""
"在外键字段上可能具有非空约束。对于大多数集合来说，这是隐含的。对单向一对多关"
"联来说，外键字段默认是可以为空的，因此你可能需要指明 <literal>not-null=\"true"
"\"</literal>。 "

#. Tag: programlisting
#: collection_mapping.xml:379
#, no-c-format
msgid "@JoinColumn(nullable=false)"
msgstr ""

#. Tag: para
#: collection_mapping.xml:381
#, no-c-format
msgid "<para>or"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:383
#, fuzzy, no-c-format
msgid "<key column=\"productSerialNumber\" not-null=\"true\"/>"
msgstr "<![CDATA["

#. Tag: para
#: collection_mapping.xml:385
#, fuzzy, no-c-format
msgid ""
"The foreign key constraint can use <literal>ON DELETE CASCADE. In "
"XML this can be expressed via:"
msgstr "外键约束可以使用 <literal>ON DELETE CASCADE。 "

#. Tag: programlisting
#: collection_mapping.xml:388
#, fuzzy, no-c-format
msgid "<key column=\"productSerialNumber\" on-delete=\"cascade\"/>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:390
#, no-c-format
msgid ""
"In annotations the Hibernate specific annotation @OnDelete has to be used."
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:393
#, no-c-format
msgid "@OnDelete(action=OnDeleteAction.CASCADE)"
msgstr ""

#. Tag: para
#: collection_mapping.xml:395
#, fuzzy, no-c-format
msgid ""
"See <xref lang=\"\" linkend=\"section.key\"/> for more information about the "
"<literal><key> element."
msgstr "对 <literal><key> 元素的完整定义，请参阅前面的章节。"

#. Tag: title
#: collection_mapping.xml:400
#, no-c-format
msgid "Indexed collections"
msgstr "索引集合类（Indexed collections）"

#. Tag: para
#: collection_mapping.xml:402
#, no-c-format
msgid ""
"In the following paragraphs we have a closer at the indexed collections "
"<classname>List and Map how the their "
"index can be mapped in Hibernate."
msgstr ""

#. Tag: title
#: collection_mapping.xml:407
#, no-c-format
msgid "Lists"
msgstr ""

#. Tag: para
#: collection_mapping.xml:409
#, no-c-format
msgid "Lists can be mapped in two different ways:"
msgstr ""

#. Tag: para
#: collection_mapping.xml:413
#, no-c-format
msgid "as ordered lists, where the order is not materialized in the database"
msgstr ""

#. Tag: para
#: collection_mapping.xml:418
#, no-c-format
msgid "as indexed lists, where the order is materialized in the database"
msgstr ""

#. Tag: para
#: collection_mapping.xml:423
#, no-c-format
msgid ""
"To order lists in memory, add <literal>@javax.persistence.OrderBy "
"to your property. This annotation takes as parameter a list of comma "
"separated properties (of the target entity) and orders the collection "
"accordingly (eg <code>firstname asc, age desc), if the string is "
"empty, the collection will be ordered by the primary key of the target "
"entity."
msgstr ""

#. Tag: title
#: collection_mapping.xml:432
#, no-c-format
msgid "Ordered lists using <classname>@OrderBy"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:434
#, no-c-format
msgid ""
"@Entity\n"
"public class Customer {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   @OneToMany(mappedBy=\"customer\")\n"
"   @OrderBy(\"number\")\n"
"   public List<Order> getOrders() { return orders; }\n"
"   public void setOrders(List<Order> orders) { this.orders = "
"orders; }\n"
"   private List<Order> orders;\n"
"}\n"
"\n"
"@Entity\n"
"public class Order {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   public String getNumber() { return number; }\n"
"   public void setNumber(String number) { this.number = number; }\n"
"   private String number;\n"
"\n"
"   @ManyToOne\n"
"   public Customer getCustomer() { return customer; }\n"
"   public void setCustomer(Customer customer) { this.customer = customer; }\n"
"   private Customer number;\n"
"}\n"
"\n"
"-- Table schema\n"
"|-------------| |----------|\n"
"| Order       | | Customer |\n"
"|-------------| |----------|\n"
"| id          | | id       |\n"
"| number      | |----------| \n"
"| customer_id |\n"
"|-------------|"
msgstr ""

#. Tag: para
#: collection_mapping.xml:437
#, no-c-format
msgid ""
"To store the index value in a dedicated column, use the <classname>@javax."
"persistence.OrderColumn</classname> annotation on your property. This "
"annotations describes the column name and attributes of the column keeping "
"the index value. This column is hosted on the table containing the "
"association foreign key. If the column name is not specified, the default is "
"the name of the referencing property, followed by underscore, followed by "
"<literal>ORDER (in the following example, it would be "
"<literal>orders_ORDER)."
msgstr ""

#. Tag: title
#: collection_mapping.xml:448
#, no-c-format
msgid "Explicit index column using <classname>@OrderColumn"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:451
#, no-c-format
msgid ""
"@Entity\n"
"public class Customer {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   @OneToMany(mappedBy=\"customer\")\n"
"   @OrderColumn(name=\"orders_index\")\n"
"   public List<Order> getOrders() { return orders; }\n"
"   public void setOrders(List<Order> orders) { this.orders = "
"orders; }\n"
"   private List<Order> orders;\n"
"}\n"
"\n"
"@Entity\n"
"public class Order {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   public String getNumber() { return number; }\n"
"   public void setNumber(String number) { this.number = number; }\n"
"   private String number;\n"
"\n"
"   @ManyToOne\n"
"   public Customer getCustomer() { return customer; }\n"
"   public void setCustomer(Customer customer) { this.customer = customer; }\n"
"   private Customer number;\n"
"}\n"
"\n"
"-- Table schema\n"
"|--------------| |----------|\n"
"| Order        | | Customer |\n"
"|--------------| |----------|\n"
"| id           | | id       |\n"
"| number       | |----------| \n"
"| customer_id  |\n"
"| orders_order |\n"
"|--------------|"
msgstr ""

#. Tag: para
#: collection_mapping.xml:455
#, no-c-format
msgid ""
"We recommend you to convert <classname>the legacy @org.hibernate.annotations."
"IndexColumn</classname> usages to @OrderColumn unless "
"you are making use of the base property. The <literal>base "
"property lets you define the index value of the first element (aka as base "
"index). The usual value is <literal>0 or 1. The "
"default is 0 like in Java."
msgstr ""

#. Tag: para
#: collection_mapping.xml:464
#, no-c-format
msgid ""
"Looking again at the Hibernate mapping file equivalent, the index of an "
"array or list is always of type <literal>integer and is mapped "
"using the <literal><list-index> element. The mapped column "
"contains sequential integers that are numbered from zero by default."
msgstr ""

#. Tag: title
#: collection_mapping.xml:471
#, no-c-format
msgid "index-list element for indexed collections in xml mapping"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:481
#, no-c-format
msgid ""
"<list-index\n"
"        column=\"column_name\"\n"
"        base=\"0|1|...\"/>"
msgstr ""

#. Tag: para
#: collection_mapping.xml:485
#, no-c-format
msgid ""
"<literal>column_name (required): the name of the column holding "
"the collection index values."
msgstr "<literal>column_name（必需）：持有集合索引值的字段的名称。 "

#. Tag: para
#: collection_mapping.xml:490
#, no-c-format
msgid ""
"<literal>base (optional - defaults to 0): the "
"value of the index column that corresponds to the first element of the list "
"or array."
msgstr ""
"<literal>base（可选 — 默认为 0）对应列表或队列的"
"第一个元素的索引字段的值。"

#. Tag: para
#: collection_mapping.xml:498
#, no-c-format
msgid ""
"If your table does not have an index column, and you still wish to use "
"<literal>List as the property type, you can map the property as a "
"Hibernate <emphasis><bag>. A bag does not retain its order "
"when it is retrieved from the database, but it can be optionally sorted or "
"ordered."
msgstr ""
"假若你的表没有一个索引字段，当你仍然希望使用 <literal>List 作为属性"
"类型，你应该把此属性映射为 Hibernate <emphasis><bag>。从数据"
"库中获取的时候，bag 不维护其顺序，但也可选择性的进行排序。 "

#. Tag: title
#: collection_mapping.xml:506
#, no-c-format
msgid "Maps"
msgstr ""

#. Tag: para
#: collection_mapping.xml:508
#, no-c-format
msgid ""
"The question with <classname>Maps is where the key value is "
"stored. There are everal options. Maps can borrow their keys from one of the "
"associated entity properties or have dedicated columns to store an explicit "
"key."
msgstr ""

#. Tag: para
#: collection_mapping.xml:513
#, no-c-format
msgid ""
"To use one of the target entity property as a key of the map, use "
"<literal>@MapKey(name=\"myProperty\"), where myProperty without the name attribuate, the target entity "
"primary key is used. The map key uses the same column as the property "
"pointed out. There is no additional column defined to hold the map key, "
"because the map key represent a target property. Be aware that once loaded, "
"the key is no longer kept in sync with the property. In other words, if you "
"change the property value, the key will not change automatically in your "
"Java model."
msgstr ""

#. Tag: title
#: collection_mapping.xml:525
#, no-c-format
msgid ""
"Use of target entity property as map key via <classname>@MapKey"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:528
#, no-c-format
msgid ""
"@Entity\n"
"public class Customer {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   @OneToMany(mappedBy=\"customer\")\n"
"   @MapKey(name=\"number\")\n"
"   public Map<String,Order> getOrders() { return orders; }\n"
"   public void setOrders(Map<String,Order> order) { this.orders = "
"orders; }\n"
"   private Map<String,Order> orders;\n"
"}\n"
"\n"
"@Entity\n"
"public class Order {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   public String getNumber() { return number; }\n"
"   public void setNumber(String number) { this.number = number; }\n"
"   private String number;\n"
"\n"
"   @ManyToOne\n"
"   public Customer getCustomer() { return customer; }\n"
"   public void setCustomer(Customer customer) { this.customer = customer; }\n"
"   private Customer number;\n"
"}\n"
"\n"
"-- Table schema\n"
"|-------------| |----------|\n"
"| Order       | | Customer |\n"
"|-------------| |----------|\n"
"| id          | | id       |\n"
"| number      | |----------| \n"
"| customer_id |\n"
"|-------------|"
msgstr ""

#. Tag: para
#: collection_mapping.xml:531
#, no-c-format
msgid ""
"Alternatively the map key is mapped to a dedicated column or columns. In "
"order to customize the mapping use one of the following annotations:"
msgstr ""

#. Tag: para
#: collection_mapping.xml:537
#, no-c-format
msgid ""
"@<classname>MapKeyColumn if the map key is a basic type. If you "
"don't specify the column name, the name of the property followed by "
"underscore followed by <literal>KEY is used (for example "
"<literal>orders_KEY)."
msgstr ""

#. Tag: para
#: collection_mapping.xml:544
#, no-c-format
msgid ""
"<classname>@MapKeyEnumerated / @MapKeyTemporalDate/@MapKeyJoinColumns/@AttributeOverrideskey. to define the type of "
"the key if you don't use generics."
msgstr ""

#. Tag: title
#: collection_mapping.xml:566
#, no-c-format
msgid "Map key as basic type using <classname>@MapKeyColumn"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:569
#, no-c-format
msgid ""
"@Entity\n"
"public class Customer {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   @OneToMany @JoinTable(name=\"Cust_Order\")\n"
"   @MapKeyColumn(name=\"orders_number\")\n"
"   public Map<String,Order> getOrders() { return orders; }\n"
"   public void setOrders(Map<String,Order> orders) { this.orders = "
"orders; }\n"
"   private Map<String,Order> orders;\n"
"}\n"
"\n"
"@Entity\n"
"public class Order {\n"
"   @Id @GeneratedValue public Integer getId() { return id; }\n"
"   public void setId(Integer id) { this.id = id; }\n"
"   private Integer id;\n"
"\n"
"   public String getNumber() { return number; }\n"
"   public void setNumber(String number) { this.number = number; }\n"
"   private String number;\n"
"\n"
"   @ManyToOne\n"
"   public Customer getCustomer() { return customer; }\n"
"   public void setCustomer(Customer customer) { this.customer = customer; }\n"
"   private Customer number;\n"
"}\n"
"\n"
"-- Table schema\n"
"|-------------| |----------| |---------------|\n"
"| Order       | | Customer | | Cust_Order    |\n"
"|-------------| |----------| |---------------|\n"
"| id          | | id       | | customer_id   |\n"
"| number      | |----------| | order_id      |\n"
"| customer_id |              | orders_number |\n"
"|-------------|              |---------------|"
msgstr ""

#. Tag: para
#: collection_mapping.xml:573
#, no-c-format
msgid ""
"We recommend you to migrate from <classname>@org.hibernate.annotations."
"MapKey</classname> / @org.hibernate.annotation.MapKeyManyToMany, "
"<literal><map-key-many-to-many> and <composite-"
"map-key></literal>. <map-key> is used for any "
"basic type, <literal><map-key-many-to-many> for an entity "
"reference and <literal><composite-map-key> for a composite "
"type."
msgstr ""
"除了 <literal><set>，还有<list>，"
"<literal><map>，<bag>，<"
"array></literal> 和 <primitive-array> 映射元素。"
"<literal><map> 具有代表性："

#. Tag: title
#: collection_mapping.xml:590
#, no-c-format
msgid "map-key xml mapping element"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:601
#, no-c-format
msgid ""
"<map-key\n"
"        column=\"column_name\"\n"
"        formula=\"any SQL expression\"\n"
"        type=\"type_name\"\n"
"        node=\"@attribute-name\"\n"
"        length=\"N\"/>"
msgstr ""

#. Tag: para
#: collection_mapping.xml:605
#, no-c-format
msgid ""
"<literal>column (optional): the name of the column holding the "
"collection index values."
msgstr "<literal>column（可选）：持有集合索引值的字段的名称。"

#. Tag: para
#: collection_mapping.xml:610
#, no-c-format
msgid ""
"<literal>formula (optional): a SQL formula used to evaluate the "
"key of the map."
msgstr "<literal>formula（可选）：用于对表键求值的 SQL 公式。"

#. Tag: para
#: collection_mapping.xml:615
#, no-c-format
msgid "<literal>type (required): the type of the map keys."
msgstr "<literal>type（必需）：映射键的类型。 "

#. Tag: title
#: collection_mapping.xml:623
#, fuzzy, no-c-format
msgid "map-key-many-to-many"
msgstr "多对多（many-to-many）"

#. Tag: programlisting
#: collection_mapping.xml:634
#, no-c-format
msgid ""
"<map-key-many-to-many\n"
"        column=\"column_name\"\n"
"        formula=\"any SQL expression\"\n"
"        class=\"ClassName\"\n"
"/>"
msgstr ""

#. Tag: para
#: collection_mapping.xml:638
#, no-c-format
msgid ""
"<literal>column (optional): the name of the foreign key column for "
"the collection index values."
msgstr "<literal>column（可选）：用于集合索引值的外键字段的名称。"

#. Tag: para
#: collection_mapping.xml:643
#, no-c-format
msgid ""
"<literal>formula (optional): a SQ formula used to evaluate the "
"foreign key of the map key."
msgstr ""
"<literal>formula（可选）：用于对映射键的外键求值的 SQL 公式。"

#. Tag: para
#: collection_mapping.xml:648
#, no-c-format
msgid ""
"<literal>class (required): the entity class used as the map key."
msgstr "<literal>class（必需）：用作映射键的实体类的名称。 "

#. Tag: title
#: collection_mapping.xml:658
#, fuzzy, no-c-format
msgid "Collections of basic types and embeddable objects"
msgstr ""
"值集合于多对多关联（Collections of values and many-to-many associations）"

#. Tag: para
#: collection_mapping.xml:660
#, no-c-format
msgid ""
"In some situations you don't need to associate two entities but simply "
"create a collection of basic types or embeddable objects. Use the "
"<classname>@ElementCollection for this case."
msgstr ""

#. Tag: title
#: collection_mapping.xml:665
#, no-c-format
msgid ""
"Collection of basic types mapped via <classname>@ElementCollection annotation. If omitted the "
"collection table name defaults to the concatenation of the name of the "
"containing entity and the name of the collection attribute, separated by an "
"underscore. In our example, it would be <literal>User_nicknames."
msgstr ""

#. Tag: para
#: collection_mapping.xml:678
#, no-c-format
msgid ""
"The column holding the basic type is set using the <classname>@Column."
msgstr ""

#. Tag: para
#: collection_mapping.xml:683
#, no-c-format
msgid ""
"But you are not limited to basic types, the collection type can be any "
"embeddable object. To override the columns of the embeddable object in the "
"collection table, use the <classname>@AttributeOverride "
"annotation."
msgstr ""

#. Tag: title
#: collection_mapping.xml:689
#, no-c-format
msgid "@ElementCollection for embeddable objects"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:691
#, no-c-format
msgid ""
"@Entity\n"
"public class User {\n"
"   [...]\n"
"   public String getLastname() { ...}\n"
"\n"
"   @ElementCollection\n"
"   @CollectionTable(name=\"Addresses\", joinColumns=@JoinColumn(name="
"\"user_id\"))\n"
"   @AttributeOverrides({\n"
"      @AttributeOverride(name=\"street1\", column=@Column(name=\"fld_street"
"\"))\n"
"   })\n"
"   public Set<Address> getAddresses() { ... } \n"
"}\n"
"\n"
"@Embeddable\n"
"public class Address {\n"
"   public String getStreet1() {...}\n"
"   [...]\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:694
#, no-c-format
msgid "Such an embeddable object cannot contains a collection itself."
msgstr ""

#. Tag: para
#: collection_mapping.xml:698
#, no-c-format
msgid ""
"in <classname>@AttributeOverride, you must use the "
"<literal>value. prefix to override properties of the embeddable "
"object used in the map value and the <literal>key. prefix to "
"override properties of the embeddable object used in the map key."
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:704
#, no-c-format
msgid ""
"@Entity\n"
"public class User {\n"
"   @ElementCollection\n"
"   @AttributeOverrides({\n"
"      @AttributeOverride(name=\"key.street1\", column=@Column(name="
"\"fld_street\")),\n"
"      @AttributeOverride(name=\"value.stars\", column=@Column(name=\"fld_note"
"\"))\n"
"   })\n"
"   public Map<Address,Rating> getFavHomes() { ... }"
msgstr ""

#. Tag: para
#: collection_mapping.xml:708
#, no-c-format
msgid ""
"We recommend you to migrate from <classname>@org.hibernate.annotations."
"CollectionOfElements</classname> to the new @ElementCollection tag. For example:"
msgstr ""
"对于一个值集合，我们使用 <literal><element> 标签。例如："

#. Tag: title
#: collection_mapping.xml:718
#, no-c-format
msgid "<element> tag for collection values using mapping files"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:730
#, no-c-format
msgid ""
"<element\n"
"        column=\"column_name\"\n"
"        formula=\"any SQL expression\"\n"
"        type=\"typename\"\n"
"        length=\"L\"\n"
"        precision=\"P\"\n"
"        scale=\"S\"\n"
"        not-null=\"true|false\"\n"
"        unique=\"true|false\"\n"
"        node=\"element-name\"\n"
"/>"
msgstr ""

#. Tag: para
#: collection_mapping.xml:734
#, no-c-format
msgid ""
"<literal>column (optional): the name of the column holding the "
"collection element values."
msgstr "<literal>column（可选）：持有集合元素值的字段的名称。"

#. Tag: para
#: collection_mapping.xml:739
#, no-c-format
msgid ""
"<literal>formula (optional): an SQL formula used to evaluate the "
"element."
msgstr "<literal>formula（可选）：用于对元素求值的 SQL 公式。"

#. Tag: para
#: collection_mapping.xml:744
#, no-c-format
msgid "<literal>type (required): the type of the collection element."
msgstr "<literal>type（必需）：集合元素的类型。 "

#. Tag: title
#: collection_mapping.xml:754
#, no-c-format
msgid "Advanced collection mappings"
msgstr "高级集合映射（Advanced collection mappings）"

#. Tag: title
#: collection_mapping.xml:757
#, no-c-format
msgid "Sorted collections"
msgstr "有序集合（Sorted collections）"

#. Tag: para
#: collection_mapping.xml:759
#, no-c-format
msgid ""
"Hibernate supports collections implementing <literal>java.util.SortedMapjava.util.SortedSet. With annotations you "
"declare a sort comparator using <literal>@Sort. You chose between "
"the comparator types unsorted, natural or custom. If you want to use your "
"own comparator implementation, you'll also have to specify the "
"implementation class using the <literal>comparator attribute. Note "
"that you need to use either a <classname>SortedSet or a "
"<classname>SortedMap interface."
msgstr ""

#. Tag: title
#: collection_mapping.xml:770
#, fuzzy, no-c-format
msgid "Sorted collection with @Sort"
msgstr "有序集合（Sorted collections）"

#. Tag: programlisting
#: collection_mapping.xml:772
#, no-c-format
msgid ""
"@OneToMany(cascade=CascadeType.ALL, fetch=FetchType.EAGER)\n"
"@JoinColumn(name=\"CUST_ID\")\n"
"@Sort(type = SortType.COMPARATOR, comparator = TicketComparator.class)\n"
"public SortedSet<Ticket> getTickets() {\n"
"    return tickets;\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:775
#, no-c-format
msgid ""
"Using Hibernate mapping files you specify a comparator in the mapping file "
"with <literal><sort>:"
msgstr ""

#. Tag: title
#: collection_mapping.xml:779
#, fuzzy, no-c-format
msgid "Sorted collection using xml mapping"
msgstr "有序集合（Sorted collections）"

#. Tag: programlisting
#: collection_mapping.xml:781
#, fuzzy, no-c-format
msgid ""
"<set name=\"aliases\"\n"
"            table=\"person_aliases\" \n"
"            sort=\"natural\">\n"
"    <key column=\"person\"/>\n"
"    <element column=\"name\" type=\"string\"/>\n"
"</set>\n"
"\n"
"<map name=\"holidays\" sort=\"my.custom.HolidayComparator\">\n"
"    <key column=\"year_id\"/>\n"
"    <map-key column=\"hol_name\" type=\"string\"/>\n"
"    <element column=\"hol_date\" type=\"date\"/>\n"
"</map>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:784
#, no-c-format
msgid ""
"Allowed values of the <literal>sort attribute are "
"<literal>unsorted, natural and the name of a "
"class implementing <literal>java.util.Comparator."
msgstr ""
"<literal>sort 属性中允许的值包括 unsorted，"
"<literal>natural 和某个实现了 java.util.Comparator "
"or <literal>java.util.TreeMap."
msgstr ""
"分类集合的行为事实上象 <literal>java.util.TreeSet 或者 "
"<literal>java.util.TreeMap。"

#. Tag: para
#: collection_mapping.xml:794
#, fuzzy, no-c-format
msgid ""
"If you want the database itself to order the collection elements, use the "
"<literal>order-by attribute of set, "
"<literal>bag or map mappings. This solution is "
"implemented using <literal>LinkedHashSet or "
"<literal>LinkedHashMap and performs the ordering in the SQL query "
"and not in the memory."
msgstr ""
"如果你希望数据库自己对集合元素排序，可以利用 <literal>set，"
"<literal>bag 或者 map 映射中的 order-"
"by</literal> 属性。这个解决方案只能在 jdk1.4 或者更高的 jdk 版本中才可以实现"
"（通过 LinkedHashSet 或者 LinkedHashMap 实现）。它是在 SQL 查询中完成排序，而"
"不是在内存中。 "

#. Tag: title
#: collection_mapping.xml:802
#, no-c-format
msgid "Sorting in database using order-by"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:804
#, fuzzy, no-c-format
msgid ""
"<set name=\"aliases\" table=\"person_aliases\" order-by=\"lower(name) asc"
"\">\n"
"    <key column=\"person\"/>\n"
"    <element column=\"name\" type=\"string\"/>\n"
"</set>\n"
"\n"
"<map name=\"holidays\" order-by=\"hol_date, hol_name\">\n"
"    <key column=\"year_id\"/>\n"
"    <map-key column=\"hol_name\" type=\"string\"/>\n"
"    <element column=\"hol_date type=\"date\"/>\n"
"</map>"
msgstr ""
"<![CDATA["

#. Tag: title
#: collection_mapping.xml:808
#, no-c-format
msgid "Note"
msgstr "注意"

#. Tag: para
#: collection_mapping.xml:810
#, no-c-format
msgid ""
"The value of the <literal>order-by attribute is an SQL ordering, "
"not an HQL ordering."
msgstr ""
"注意：这个 <literal>order-by 属性的值是一个 SQL 排序子句而不是 HQL "
"的。"

#. Tag: para
#: collection_mapping.xml:814
#, no-c-format
msgid ""
"Associations can even be sorted by arbitrary criteria at runtime using a "
"collection <literal>filter():"
msgstr ""
"关联还可以在运行时使用集合 <literal>filter() 根据任意的条件来排序："

#. Tag: title
#: collection_mapping.xml:818
#, no-c-format
msgid "Sorting via a query filter"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:820
#, fuzzy, no-c-format
msgid ""
"sortedUsers = s.createFilter( group.getUsers(), \"order by this.name\" ).list"
"();"
msgstr ""
"<![CDATA[sortedUsers = s.createFilter( group.getUsers(), \"order by this.name"
"\" ).list();]]>"

#. Tag: title
#: collection_mapping.xml:825
#, no-c-format
msgid "Bidirectional associations"
msgstr "双向关联（Bidirectional associations）"

#. Tag: para
#: collection_mapping.xml:827
#, no-c-format
msgid ""
"A <emphasis>bidirectional association allows navigation from both "
"\"ends\" of the association. Two kinds of bidirectional association are "
"supported:"
msgstr ""
"<emphasis>双向关联允许通过关联的任一端访问另外一端。在 Hibernate "
"中，支持两种类型的双向关联： "

#. Tag: term
#: collection_mapping.xml:831
#, no-c-format
msgid "one-to-many"
msgstr "一对多（one-to-many）"

#. Tag: para
#: collection_mapping.xml:834
#, no-c-format
msgid "set or bag valued at one end and single-valued at the other"
msgstr "Set 或者 bag 值在一端，单独值（非集合）在另外一端 "

#. Tag: term
#: collection_mapping.xml:840
#, no-c-format
msgid "many-to-many"
msgstr "多对多（many-to-many）"

#. Tag: para
#: collection_mapping.xml:843
#, no-c-format
msgid "set or bag valued at both ends"
msgstr "两端都是 set 或 bag 值"

#. Tag: para
#: collection_mapping.xml:848
#, no-c-format
msgid ""
"Often there exists a many to one association which is the owner side of a "
"bidirectional relationship. The corresponding one to many association is in "
"this case annotated by <literal>@OneToMany(mappedBy=...)"
msgstr ""

#. Tag: title
#: collection_mapping.xml:854
#, no-c-format
msgid "Bidirectional one to many with many to one side as association owner"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:857
#, no-c-format
msgid ""
"@Entity\n"
"public class Troop {\n"
"    @OneToMany(mappedBy=\"troop\")\n"
"    public Set<Soldier> getSoldiers() {\n"
"    ...\n"
"}\n"
"\n"
"@Entity\n"
"public class Soldier {\n"
"    @ManyToOne\n"
"    @JoinColumn(name=\"troop_fk\")\n"
"    public Troop getTroop() {\n"
"    ...\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:860
#, no-c-format
msgid ""
"<classname>Troop has a bidirectional one to many relationship "
"with <literal>Soldier through the troop "
"property. You don't have to (must not) define any physical mapping in the "
"<literal>mappedBy side."
msgstr ""

#. Tag: para
#: collection_mapping.xml:865
#, no-c-format
msgid ""
"To map a bidirectional one to many, with the one-to-many side as the owning "
"side, you have to remove the <literal>mappedBy element and set the "
"many to one <literal>@JoinColumn as insertable and updatable to "
"false. This solution is not optimized and will produce additional UPDATE "
"statements."
msgstr ""

#. Tag: title
#: collection_mapping.xml:872
#, fuzzy, no-c-format
msgid "Bidirectional associtaion with one to many side as owner"
msgstr "双向关联，涉及有序集合类"

#. Tag: programlisting
#: collection_mapping.xml:875
#, no-c-format
msgid ""
"@Entity\n"
"public class Troop {\n"
"    @OneToMany\n"
"    @JoinColumn(name=\"troop_fk\") //we need to duplicate the physical "
"information\n"
"    public Set<Soldier> getSoldiers() {\n"
"    ...\n"
"}\n"
"\n"
"@Entity\n"
"public class Soldier {\n"
"    @ManyToOne\n"
"    @JoinColumn(name=\"troop_fk\", insertable=false, updatable=false)\n"
"    public Troop getTroop() {\n"
"    ...\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:878
#, fuzzy, no-c-format
msgid ""
"How does the mappping of a bidirectional mapping look like in Hibernate "
"mapping xml? There you define a bidirectional one-to-many association by "
"mapping a one-to-many association to the same table column(s) as a many-to-"
"one association and declaring the many-valued end <literal>inverse=\"true\""

#. Tag: para
#: collection_mapping.xml:890
#, no-c-format
msgid ""
"Mapping one end of an association with <literal>inverse=\"true\" "
"does not affect the operation of cascades as these are orthogonal concepts."
msgstr ""
"在“一”这一端定义 <literal>inverse=\"true\" 不会影响级联操作，二者是"
"正交的概念。"

#. Tag: para
#: collection_mapping.xml:894
#, no-c-format
msgid ""
"A many-to-many association is defined logically using the "
"<literal>@ManyToMany annotation. You also have to describe the "
"association table and the join conditions using the <literal>@JoinTable defines a name primary key (the \"other side\"). As seen "
"previously, the other side don't have to (must not) describe the physical "
"mapping: a simple <literal>mappedBy argument containing the owner "
"side property name bind the two."
msgstr ""

#. Tag: para
#: collection_mapping.xml:919
#, no-c-format
msgid ""
"As any other annotations, most values are guessed in a many to many "
"relationship. Without describing any physical mapping in a unidirectional "
"many to many the following rules applied. The table name is the "
"concatenation of the owner table name, <keycap>_ and the other side "
"table name. The foreign key name(s) referencing the owner table is the "
"concatenation of the owner table name, <keycap>_ and the owner "
"primary key column(s). The foreign key name(s) referencing the other side is "
"the concatenation of the owner property name, <keycap>_, and the "
"other side primary key column(s). These are the same rules used for a "
"unidirectional one to many relationship."
msgstr ""

#. Tag: title
#: collection_mapping.xml:932
#, no-c-format
msgid "Default values for <classname>@ManyToMany (uni-directional)"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:935
#, no-c-format
msgid ""
"@Entity\n"
"public class Store {\n"
"    @ManyToMany(cascade = CascadeType.PERSIST)\n"
"    public Set<City> getImplantedIn() {\n"
"        ...\n"
"    }\n"
"}\n"
"\n"
"@Entity\n"
"public class City {\n"
"    ... //no bidirectional relationship\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:938
#, no-c-format
msgid ""
"A <literal>Store_City is used as the join table. The "
"<literal>Store_id column is a foreign key to the StoreimplantedIn_id column is a foreign "
"key to the <literal>City table."
msgstr ""

#. Tag: para
#: collection_mapping.xml:943
#, no-c-format
msgid ""
"Without describing any physical mapping in a bidirectional many to many the "
"following rules applied. The table name is the concatenation of the owner "
"table name, <keycap>_ and the other side table name. The foreign "
"key name(s) referencing the owner table is the concatenation of the other "
"side property name, <keycap>_, and the owner primary key column(s). "
"The foreign key name(s) referencing the other side is the concatenation of "
"the owner property name, <keycap>_, and the other side primary key "
"column(s). These are the same rules used for a unidirectional one to many "
"relationship."
msgstr ""

#. Tag: title
#: collection_mapping.xml:955
#, no-c-format
msgid "Default values for <classname>@ManyToMany (bi-directional)"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:958
#, no-c-format
msgid ""
"@Entity\n"
"public class Store {\n"
"    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})\n"
"    public Set<Customer> getCustomers() {\n"
"        ...\n"
"    }\n"
"}\n"
"\n"
"@Entity\n"
"public class Customer {\n"
"    @ManyToMany(mappedBy=\"customers\")\n"
"    public Set<Store> getStores() {\n"
"        ...\n"
"    }\n"
"}"
msgstr ""

#. Tag: para
#: collection_mapping.xml:961
#, no-c-format
msgid ""
"A <literal>Store_Customer is used as the join table. The "
"<literal>stores_id column is a foreign key to the Storecustomers_id column is a foreign key "
"to the <literal>Customer table."
msgstr ""

#. Tag: para
#: collection_mapping.xml:966
#, fuzzy, no-c-format
msgid ""
"Using Hibernate mapping files you can map a bidirectional many-to-many "
"association by mapping two many-to-many associations to the same database "
"table and declaring one end as <emphasis>inverse."
msgstr ""
"要建立一个双向的多对多关联，只需要映射两个 many-to-many 关联到同一个数据库表"
"中，并再定义其中的一端为 <emphasis>inverse（使用哪一端要根据你的选"
"择，但它不能是一个索引集合）。 "

#. Tag: para
#: collection_mapping.xml:970
#, no-c-format
msgid "You cannot select an indexed collection."
msgstr ""

#. Tag: para
#: collection_mapping.xml:973
#, fuzzy, no-c-format
msgid ""
"shows a bidirectional many-to-many association that illustrates how each "
"category can have many items and each item can be in many categories:"
msgstr ""
"这里有一个 many-to-many 的双向关联的例子;每一个 category 都可以有很多 items，"
"每一个 items 可以属于很多 categories： "

#. Tag: title
#: collection_mapping.xml:979
#, no-c-format
msgid "Many to many association using Hibernate mapping files"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:981
#, fuzzy, no-c-format
msgid ""
"<class name=\"Category\">\n"
"    <id name=\"id\" column=\"CATEGORY_ID\"/>\n"
"    ...\n"
"    <bag name=\"items\" table=\"CATEGORY_ITEM\">\n"
"        <key column=\"CATEGORY_ID\"/>\n"
"        <many-to-many class=\"Item\" column=\"ITEM_ID\"/>\n"
"    </bag>\n"
"</class>\n"
"\n"
"<class name=\"Item\">\n"
"    <id name=\"id\" column=\"ITEM_ID\"/>\n"
"    ...\n"
"\n"
"    <!-- inverse end -->\n"
"    <bag name=\"categories\" table=\"CATEGORY_ITEM\" inverse=\"true"
"\">\n"
"        <key column=\"ITEM_ID\"/>\n"
"        <many-to-many class=\"Category\" column=\"CATEGORY_ID\"/>\n"
"    </bag>\n"
"</class>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:984
#, no-c-format
msgid ""
"Changes made only to the inverse end of the association are <emphasis>not被持久化。 "
"这表示 Hibernate 为每个双向关联在内存中存在两次表现，一个从 A 连接到 B，另一"
"个从 B 连接到 A。如果你回想一下 Java 对象模型，我们是如何在 Java 中创建多对多"
"关系的，这可以让你更容易理解： "

#. Tag: title
#: collection_mapping.xml:992
#, fuzzy, no-c-format
msgid "Effect of inverse vs. non-inverse side of many to many associations"
msgstr ""
"值集合于多对多关联（Collections of values and many-to-many associations）"

#. Tag: programlisting
#: collection_mapping.xml:995
#, fuzzy, no-c-format
msgid ""
"category.getItems().add(item);           // The category now \"knows\" about "
"the relationship\n"
"item.getCategories().add(category);      // The item now \"knows\" about the "
"relationship\n"
"\n"
"session.persist(item);                   // The relationship won't be "
"saved!\n"
"session.persist(category);               // The relationship will be saved"
msgstr ""
"<![CDATA[\n"
"category.getItems().add(item);          // The category now \"knows\" about "
"the relationship\n"
"item.getCategories().add(category);     // The item now \"knows\" about the "
"relationship\n"
"\n"
"session.persist(item);                   // The relationship won't be "
"saved!\n"
"session.persist(category);               // The relationship will be saved]]>"

#. Tag: para
#: collection_mapping.xml:998
#, no-c-format
msgid ""
"The non-inverse side is used to save the in-memory representation to the "
"database."
msgstr "非反向端用于把内存中的表示保存到数据库中。"

#. Tag: title
#: collection_mapping.xml:1003
#, no-c-format
msgid "Bidirectional associations with indexed collections"
msgstr "双向关联，涉及有序集合类"

#. Tag: para
#: collection_mapping.xml:1005
#, fuzzy, no-c-format
msgid ""
"There are some additional considerations for bidirectional mappings with "
"indexed collections (where one end is represented as a <literal><list>"
"</literal> or <map>) when using Hibernate mapping "
"files. If there is a property of the child class that maps to the index "
"column you can use <literal>inverse=\"true\" on the collection "
"mapping:"
msgstr ""
"对于有一端是 <literal><list> 或者 <map>： "

#. Tag: title
#: collection_mapping.xml:1013
#, fuzzy, no-c-format
msgid "Bidirectional association with indexed collection"
msgstr "双向关联，涉及有序集合类"

#. Tag: programlisting
#: collection_mapping.xml:1015
#, fuzzy, no-c-format
msgid ""
"<class name=\"Parent\">\n"
"    <id name=\"id\" column=\"parent_id\"/>\n"
"    ....\n"
"    <map name=\"children\" inverse=\"true\">\n"
"        <key column=\"parent_id\"/>\n"
"        <map-key column=\"name\" \n"
"            type=\"string\"/>\n"
"        <one-to-many class=\"Child\"/>\n"
"    </map>\n"
"</class>\n"
"\n"
"<class name=\"Child\">\n"
"    <id name=\"id\" column=\"child_id\"/>\n"
"    ....\n"
"    <property name=\"name\" \n"
"        not-null=\"true\"/>\n"
"    <many-to-one name=\"parent\" \n"
"        class=\"Parent\" \n"
"        column=\"parent_id\"\n"
"        not-null=\"true\"/>\n"
"</class>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1018
#, no-c-format
msgid ""
"If there is no such property on the child class, the association cannot be "
"considered truly bidirectional. That is, there is information available at "
"one end of the association that is not available at the other end. In this "
"case, you cannot map the collection <literal>inverse=\"true\". "
"Instead, you could use the following mapping:"
msgstr ""
"但是，假若子类中没有这样的属性存在，我们不能认为这个关联是真正的双向关联（信"
"息不对称，在关联的一端有一些另外一端没有的信息）。在这种情况下，我们不能使用 "
"<literal>inverse=\"true\"。我们需要这样用： "

#. Tag: title
#: collection_mapping.xml:1026
#, fuzzy, no-c-format
msgid "Bidirectional association with indexed collection, but no index column"
msgstr "双向关联，涉及有序集合类"

#. Tag: programlisting
#: collection_mapping.xml:1029
#, fuzzy, no-c-format
msgid ""
"<class name=\"Parent\">\n"
"    <id name=\"id\" column=\"parent_id\"/>\n"
"    ....\n"
"    <map name=\"children\">\n"
"        <key column=\"parent_id\"\n"
"            not-null=\"true\"/>\n"
"        <map-key column=\"name\" \n"
"            type=\"string\"/>\n"
"        <one-to-many class=\"Child\"/>\n"
"    </map>\n"
"</class>\n"
"\n"
"<class name=\"Child\">\n"
"    <id name=\"id\" column=\"child_id\"/>\n"
"    ....\n"
"    <many-to-one name=\"parent\" \n"
"        class=\"Parent\" \n"
"        column=\"parent_id\"\n"
"        insert=\"false\"\n"
"        update=\"false\"\n"
"        not-null=\"true\"/>\n"
"</class>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1032
#, no-c-format
msgid ""
"Note that in this mapping, the collection-valued end of the association is "
"responsible for updates to the foreign key."
msgstr "注意在这个映射中，关联中集合类\"值\"一端负责来更新外键。"

#. Tag: title
#: collection_mapping.xml:1037
#, no-c-format
msgid "Ternary associations"
msgstr "三重关联（Ternary associations）"

#. Tag: para
#: collection_mapping.xml:1039
#, no-c-format
msgid ""
"There are three possible approaches to mapping a ternary association. One "
"approach is to use a <literal>Map with an association as its index:"
msgstr ""
"有三种可能的途径来映射一个三重关联。第一种是使用一个 <literal>Map，"
"把一个关联作为其索引： "

#. Tag: title
#: collection_mapping.xml:1044
#, fuzzy, no-c-format
msgid "Ternary association mapping"
msgstr "三重关联（Ternary associations）"

#. Tag: programlisting
#: collection_mapping.xml:1046
#, no-c-format
msgid ""
"@Entity\n"
"public class Company {\n"
"   @Id \n"
"   int id;\n"
"   ...\n"
"   @OneToMany // unidirectional\n"
"   @MapKeyJoinColumn(name=\"employee_id\")\n"
"   Map<Employee, Contract> contracts;\n"
"}\n"
"\n"
"// or\n"
"\n"
"<map name=\"contracts\">\n"
"    <key column=\"employer_id\" not-null=\"true\"/>\n"
"    <map-key-many-to-many column=\"employee_id\" class=\"Employee\"/>\n"
"    <one-to-many class=\"Contract\"/>\n"
"</map>"
msgstr ""

#. Tag: para
#: collection_mapping.xml:1049
#, fuzzy, no-c-format
msgid ""
"A second approach is to remodel the association as an entity class. This is "
"the most common approach. A final alternative is to use composite elements, "
"which will be discussed later."
msgstr ""
"第二种方法是简单的把关联重新建模为一个实体类。这使我们最经常使用的方法。 "

#. Tag: literal
#: collection_mapping.xml:1055
#, fuzzy, no-c-format
msgid "Using an <idbag>"
msgstr "<literal>使用 an <idbag> "

#. Tag: para
#: collection_mapping.xml:1057
#, fuzzy, no-c-format
msgid ""
"The majority of the many-to-many associations and collections of values "
"shown previously all map to tables with composite keys, even though it has "
"been suggested that entities should have synthetic identifiers (surrogate "
"keys). A pure association table does not seem to benefit much from a "
"surrogate key, although a collection of composite values <emphasis>might会获得一点好处）。不过，"
"Hibernate 提供了一个（一点点试验性质的）功能，让你把多对多关联和值集合应得到"
"一个使用代用标识符的表去。 "

#. Tag: para
#: collection_mapping.xml:1066
#, no-c-format
msgid ""
"The <literal><idbag> element lets you map a ListCollection) with bag semantics. For example:"
msgstr ""
"<literal><idbag> 属性让你使用 bag 语义来映射一个 "
"<literal>List （或 Collection）。 "

#. Tag: programlisting
#: collection_mapping.xml:1070
#, fuzzy, no-c-format
msgid ""
"<idbag name=\"lovers\" table=\"LOVERS\">\n"
"    <collection-id column=\"ID\" type=\"long\">\n"
"        <generator class=\"sequence\"/>\n"
"    </collection-id>\n"
"    <key column=\"PERSON1\"/>\n"
"    <many-to-many column=\"PERSON2\" class=\"Person\" fetch=\"join\"/"
">\n"
"</idbag>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1072
#, no-c-format
msgid ""
"An <literal><idbag> has a synthetic id generator, just like "
"an entity class. A different surrogate key is assigned to each collection "
"row. Hibernate does not, however, provide any mechanism for discovering the "
"surrogate key value of a particular row."
msgstr ""
"你可以理解，<literal><idbag> 人工的 id 生成器，就好像是实体类"
"一样！集合的每一行都有一个不同的人造关键字。但是，Hibernate 没有提供任何机制"
"来让你取得某个特定行的人造关键字。 "

#. Tag: para
#: collection_mapping.xml:1077
#, no-c-format
msgid ""
"The update performance of an <literal><idbag> supersedes a "
"regular <literal><bag>. Hibernate can locate individual rows "
"efficiently and update or delete them individually, similar to a list, map "
"or set."
msgstr ""
"注意 <literal><idbag> 的更新性能要比普通的 <"
"bag></literal> 高得多！Hibernate 可以有效的定位到不同的行，分别进行更新或"
"删除工作，就如同处理一个 list，map 或者 set 一样。 "

#. Tag: para
#: collection_mapping.xml:1082
#, no-c-format
msgid ""
"In the current implementation, the <literal>native identifier "
"generation strategy is not supported for <literal><idbag> "
"collection identifiers."
msgstr ""
"在目前的实现中，还不支持使用 <literal>identity 标识符生成器策略来生"
"成 <literal><idbag> 集合的标识符。"

#. Tag: title
#: collection_mapping.xml:1103
#, no-c-format
msgid "Collection examples"
msgstr "集合例子（Collection example）"

#. Tag: para
#: collection_mapping.xml:1105
#, no-c-format
msgid "This section covers collection examples."
msgstr "集合例子（Collection example）。"

#. Tag: para
#: collection_mapping.xml:1107
#, no-c-format
msgid ""
"The following class has a collection of <literal>Child instances:"
msgstr "下面的代码是用来添加一个新的 <literal>Child："

#. Tag: title
#: collection_mapping.xml:1111
#, no-c-format
msgid ""
"Example classes <classname>Parent and Child 的实例集合。如果每一个子实例至多有一个"
"父实例，那么最自然的映射是一个 one-to-many 的关联关系： "

#. Tag: title
#: collection_mapping.xml:1121
#, no-c-format
msgid ""
"One to many unidirectional <classname>Parent-Child relationship "
"using annotations"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1124
#, no-c-format
msgid ""
"public class Parent {\n"
"    @Id\n"
"    @GeneratedValue\n"
"    private long id;\n"
"\n"
"    @OneToMany\n"
"    private Set<Child> children;\n"
"\n"
"    // getter/setter\n"
"    ...\n"
"}\n"
"\n"
"\n"
"public class Child {\n"
"   @Id\n"
"   @GeneratedValue\n"
"   private long id;\n"
"   private String name;\n"
"\n"
"   \n"
"   // getter/setter\n"
"   ...\n"
"}"
msgstr ""

#. Tag: title
#: collection_mapping.xml:1128
#, no-c-format
msgid ""
"One to many unidirectional <classname>Parent-Child relationship "
"using mapping files"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1131
#, fuzzy, no-c-format
msgid ""
"<hibernate-mapping>\n"
"\n"
"    <class name=\"Parent\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <set name=\"children\">\n"
"            <key column=\"parent_id\"/>\n"
"            <one-to-many class=\"Child\"/>\n"
"        </set>\n"
"    </class>\n"
"\n"
"    <class name=\"Child\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <property name=\"name\"/>\n"
"    </class>\n"
"\n"
"</hibernate-mapping>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1134
#, no-c-format
msgid "This maps to the following table definitions:"
msgstr "在以下的表定义中反应了这个映射关系："

#. Tag: title
#: collection_mapping.xml:1137
#, no-c-format
msgid ""
"Table definitions for unidirectional <classname>Parent-"
"<classname>Child relationship"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1141
#, fuzzy, no-c-format
msgid ""
"create table parent ( id bigint not null primary key )\n"
"create table child ( id bigint not null primary key, name varchar(255), "
"parent_id bigint )\n"
"alter table child add constraint childfk0 (parent_id) references parent"
msgstr ""
"<![CDATA[create table parent ( id bigint not null primary key )\n"
"create table child ( id bigint not null primary key, name varchar(255), "
"parent_id bigint )\n"
"alter table child add constraint childfk0 (parent_id) references parent]]>"

#. Tag: para
#: collection_mapping.xml:1144
#, no-c-format
msgid ""
"If the parent is <emphasis>required, use a bidirectional one-to-"
"many association:"
msgstr ""
"如果父亲是<emphasis>必须的，那么就可以使用双向 one-to-many 的关联"
"了："

#. Tag: title
#: collection_mapping.xml:1148
#, no-c-format
msgid ""
"One to many bidirectional <classname>Parent-Child relationship "
"using annotations"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1151
#, no-c-format
msgid ""
"public class Parent {\n"
"    @Id\n"
"    @GeneratedValue\n"
"    private long id;\n"
"\n"
"    @OneToMany(mappedBy=\"parent\")\n"
"    private Set<Child> children;\n"
"\n"
"    // getter/setter\n"
"    ...\n"
"}\n"
"\n"
"\n"
"public class Child {\n"
"   @Id\n"
"   @GeneratedValue\n"
"   private long id;\n"
"\n"
"   private String name;\n"
" \n"
"   @ManyToOne\n"
"   private Parent parent;\n"
"\n"
"   \n"
"   // getter/setter\n"
"   ...\n"
"}"
msgstr ""

#. Tag: title
#: collection_mapping.xml:1155
#, no-c-format
msgid ""
"One to many bidirectional <classname>Parent-Child relationship "
"using mapping files"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1158
#, fuzzy, no-c-format
msgid ""
"<hibernate-mapping>\n"
"\n"
"    <class name=\"Parent\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <set name=\"children\" inverse=\"true\">\n"
"            <key column=\"parent_id\"/>\n"
"            <one-to-many class=\"Child\"/>\n"
"        </set>\n"
"    </class>\n"
"\n"
"    <class name=\"Child\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <property name=\"name\"/>\n"
"        <many-to-one name=\"parent\" class=\"Parent\" column=\"parent_id"
"\" not-null=\"true\"/>\n"
"    </class>\n"
"\n"
"</hibernate-mapping>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1161
#, no-c-format
msgid "Notice the <literal>NOT NULL constraint:"
msgstr "请注意 <literal>NOT NULL 的约束:"

#. Tag: title
#: collection_mapping.xml:1164
#, no-c-format
msgid ""
"Table definitions for bidirectional <classname>Parent-"
"<classname>Child relationship"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1168
#, fuzzy, no-c-format
msgid ""
"create table parent ( id bigint not null primary key )\n"
"create table child ( id bigint not null\n"
"                     primary key,\n"
"                     name varchar(255),\n"
"                     parent_id bigint not null )\n"
"alter table child add constraint childfk0 (parent_id) references parent"
msgstr ""
"<![CDATA[create table parent ( id bigint not null primary key )\n"
"create table child ( id bigint not null\n"
"                     primary key,\n"
"                     name varchar(255),\n"
"                     parent_id bigint not null )\n"
"alter table child add constraint childfk0 (parent_id) references parent]]>"

#. Tag: para
#: collection_mapping.xml:1171
#, fuzzy, no-c-format
msgid ""
"Alternatively, if this association must be unidirectional you can enforce "
"the <literal>NOT NULL constraint."
msgstr ""
"另外，如果你绝对坚持这个关联应该是单向的，你可以对 <literal><key>NOT NULL 约束： "

#. Tag: title
#: collection_mapping.xml:1175
#, no-c-format
msgid ""
"Enforcing NOT NULL constraint in unidirectional relation using annotations"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1178
#, no-c-format
msgid ""
"public class Parent {\n"
"    @Id\n"
"    @GeneratedValue\n"
"    private long id;\n"
"\n"
"    @OneToMany(optional=false)\n"
"    private Set<Child> children;\n"
"\n"
"    // getter/setter\n"
"    ...\n"
"}\n"
"\n"
"\n"
"public class Child {\n"
"   @Id\n"
"   @GeneratedValue\n"
"   private long id;\n"
"   private String name;\n"
"\n"
"   \n"
"   // getter/setter\n"
"   ...\n"
"}"
msgstr ""

#. Tag: title
#: collection_mapping.xml:1182
#, no-c-format
msgid ""
"Enforcing NOT NULL constraint in unidirectional relation using mapping files"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1185
#, fuzzy, no-c-format
msgid ""
"<hibernate-mapping>\n"
"\n"
"    <class name=\"Parent\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <set name=\"children\">\n"
"            <key column=\"parent_id\" not-null=\"true\"/>\n"
"            <one-to-many class=\"Child\"/>\n"
"        </set>\n"
"    </class>\n"
"\n"
"    <class name=\"Child\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <property name=\"name\"/>\n"
"    </class>\n"
"\n"
"</hibernate-mapping>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1188
#, fuzzy, no-c-format
msgid ""
"On the other hand, if a child has multiple parents, a many-to-many "
"association is appropriate."
msgstr ""
"另外一方面，如果一个子实例可能有多个父实例，那么就应该使用 many-to-many 关"
"联： "

#. Tag: title
#: collection_mapping.xml:1192
#, no-c-format
msgid ""
"Many to many <classname>Parent-Child relationship using "
"annotations"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1195
#, no-c-format
msgid ""
"public class Parent {\n"
"    @Id\n"
"    @GeneratedValue\n"
"    private long id;\n"
"\n"
"    @ManyToMany\n"
"    private Set<Child> children;\n"
"\n"
"    // getter/setter\n"
"    ...\n"
"}\n"
"\n"
"\n"
"public class Child {\n"
"   @Id\n"
"   @GeneratedValue\n"
"   private long id;\n"
"\n"
"   private String name;\n"
"\n"
"   \n"
"   // getter/setter\n"
"   ...\n"
"}"
msgstr ""

#. Tag: title
#: collection_mapping.xml:1199
#, no-c-format
msgid ""
"Many to many <classname>Parent-Child relationship using mapping "
"files"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1202
#, fuzzy, no-c-format
msgid ""
"<hibernate-mapping>\n"
"\n"
"    <class name=\"Parent\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <set name=\"children\" table=\"childset\">\n"
"            <key column=\"parent_id\"/>\n"
"            <many-to-many class=\"Child\" column=\"child_id\"/>\n"
"        </set>\n"
"    </class>\n"
"\n"
"    <class name=\"Child\">\n"
"        <id name=\"id\">\n"
"            <generator class=\"sequence\"/>\n"
"        </id>\n"
"        <property name=\"name\"/>\n"
"    </class>\n"
"\n"
"</hibernate-mapping>"
msgstr ""
"<![CDATA["

#. Tag: para
#: collection_mapping.xml:1205
#, no-c-format
msgid "Table definitions:"
msgstr "表定义："

#. Tag: title
#: collection_mapping.xml:1208
#, no-c-format
msgid "Table definitions for many to many releationship"
msgstr ""

#. Tag: programlisting
#: collection_mapping.xml:1210
#, fuzzy, no-c-format
msgid ""
"create table parent ( id bigint not null primary key )\n"
"create table child ( id bigint not null primary key, name varchar(255) )\n"
"create table childset ( parent_id bigint not null,\n"
"                        child_id bigint not null,\n"
"                        primary key ( parent_id, child_id ) )\n"
"alter table childset add constraint childsetfk0 (parent_id) references "
"parent\n"
"alter table childset add constraint childsetfk1 (child_id) references child"
msgstr ""
"<![CDATA[create table parent ( id bigint not null primary key )\n"
"create table child ( id bigint not null primary key, name varchar(255) )\n"
"create table childset ( parent_id bigint not null,\n"
"                        child_id bigint not null,\n"
"                        primary key ( parent_id, child_id ) )\n"
"alter table childset add constraint childsetfk0 (parent_id) references "
"parent\n"
"alter table childset add constraint childsetfk1 (child_id) references child]]"
">"

#. Tag: para
#: collection_mapping.xml:1213
#, fuzzy, no-c-format
msgid ""
"For more examples and a complete explanation of a parent/child relationship "
"mapping, see <xref linkend=\"example-parentchild\"/> for more information. "
"Even more complex association mappings are covered in the next chapter."
msgstr ""
"更多的例子，以及一个完整的父/子关系映射的排练，请参阅 <xref linkend="
"\"example-parentchild\" />。  "

#~ msgid ""
#~ "Hibernate requires that persistent collection-valued fields be declared "
#~ "as an interface type. For example:"
#~ msgstr ""
#~ "（译者注：在阅读本章的时候，以后整个手册的阅读过程中，我们都会面临一个名词"
#~ "方面的问题，那就是“集合”。\"Collections\" 和 \"Set\" 在中文里对应都被翻译"
#~ "为“集合”，但是他们的含义很不一样。Collections 是一个超集，Set 是其中的一"
#~ "种。大部分情况下，本译稿中泛指的未加英文注明的“集合”，都应当理解"
#~ "为“Collections”。在有些二者同时出现，可能造成混淆的地方，我们用“集合类”来"
#~ "特指“Collecions”，“集合（Set）”来指 \"Set\"，一般都会在后面的括号中给出英"
#~ "文。希望大家在阅读时联系上下文理解，不要造成误解。 与此同时，“元素”一词对"
#~ "应的英文“element”，也有两个不同的含义。其一为集合的元素，是内存中的一个变"
#~ "量；另一含义则是 XML 文档中的一个标签所代表的元素。也请注意区别。本章中，"
#~ "特别是后半部分是需要反复阅读才能理解清楚的。如果遇到任何疑问，请记住，英文"
#~ "版本的 reference 是惟一标准的参考资料。） Hibernate 要求持久化集合值字段必"
#~ "须声明为接口，例如："

#~ msgid "Collection mappings"
#~ msgstr "集合映射（ Collection mappings ）"

#~ msgid ""
#~ "There are quite a range of mappings that can be generated for collections "
#~ "that cover many common relational models. We suggest you experiment with "
#~ "the schema generation tool so that you understand how various mapping "
#~ "declarations translate to database tables."
#~ msgstr ""
#~ "从集合类可以产生很大一部分映射，覆盖了很多常见的关系模型。我们建议你试验 "
#~ "schema 生成工具，来体会一下不同的映射声明是如何被翻译为数据库表的。 "

#~ msgid "Collection elements"
#~ msgstr "集合元素（Collection elements）"

#~ msgid ""
#~ "The contained type is referred to as the <emphasis>collection element "
#~ "type</emphasis>. Collection elements are mapped by <"
#~ "element></literal> or <composite-element>, or "
#~ "in the case of entity references, with <literal><one-to-many><many-to-many>. The first two map "
#~ "elements with value semantics, the next two are used to map entity "
#~ "associations."
#~ msgstr ""
#~ "被包容的类型被称为<emphasis>集合元素类型（collection element type）<element> 或 "
#~ "<literal><composite-element> 映射，或在其是实体引用的时"
#~ "候，通过  <literal><one-to-many> 或 <many-to-"
#~ "many></literal> 映射。前两种用于使用值语义映射元素，后两种用于映射实体"
#~ "关联。"

#~ msgid ""
#~ "All collection mappings, except those with set and bag semantics, need an "
#~ "<emphasis>index column in the collection table. An index "
#~ "column is a column that maps to an array index, or <literal>ListMap key. The index of a "
#~ "<literal>Map may be of any basic type, mapped with <"
#~ "map-key></literal>. It can be an entity reference mapped with "
#~ "<literal><map-key-many-to-many>, or it can be a composite "
#~ "type mapped with <literal><composite-map-key>. The index "
#~ "of an array or list is always of type <literal>integer and is "
#~ "mapped using the <literal><list-index> element. The "
#~ "mapped column contains sequential integers that are numbered from zero by "
#~ "default."
#~ msgstr ""
#~ "所有的集合映射，除了 set 和 bag 语义的以外，都需要指定一个集合表的"
#~ "<emphasis>索引字段（index column） — 用于对应到数组索引，或者 "
#~ "<literal>List 的索引，或者 Map 的关键字。通"
#~ "过 <literal><map-key>，Map 的索引可以是"
#~ "任何基础类型；若通过 <literal><map-key-many-to-many>，它也"
#~ "可以是一个实体引用；若通过 <literal><composite-map-key>，"
#~ "它还可以是一个组合类型。数组或列表的索引必须是 <literal>integer "
#~ "类型，并且使用 <literal><list-index> 元素定义映射。被映射"
#~ "的字段包含有顺序排列的整数（默认从 0 开始）。 "

#~ msgid ""
#~ "Any collection of values or many-to-many associations requires a "
#~ "dedicated <emphasis>collection table with a foreign key column "
#~ "or columns, <emphasis>collection element column or columns, "
#~ "and possibly an index column or columns."
#~ msgstr ""
#~ "任何值集合或者多对多关联需要专用的具有一个或多个外键字段的 "
#~ "<emphasis>collection table、一个或多个 collection "
#~ "element column</emphasis>，以及还可能有一个或多个索引字段。 "

#~ msgid ""
#~ "A <emphasis>many-to-many association is specified using the "
#~ "<literal><many-to-many> element."
#~ msgstr ""
#~ "用 <literal><many-to-many> 元素指定 many-to-"
#~ "many association</emphasis>。"

#~ msgid ""
#~ "<literal>column (optional): the name of the element foreign key "
#~ "column."
#~ msgstr "<literal>column（必需）：元素外键字段的名称。 "

#~ msgid ""
#~ "<literal>formula (optional): an SQL formula used to evaluate "
#~ "the element foreign key value."
#~ msgstr ""
#~ "<literal>formula（可选）：用于对元素外键值求值的 SQL 公式。"

#~ msgid ""
#~ "<literal>fetch (optional - defaults to join of an entity and its many-to-many relationships "
#~ "to other entities, you would enable <literal>join fetching,not "
#~ "only of the collection itself, but also with this attribute on the "
#~ "<literal><many-to-many> nested element."
#~ msgstr ""
#~ "<literal>fetch（可选 - 缺省为 join）： 为这个"
#~ "关联启用外连接或序列性选择抓取。这是一个特例。对于在单个 <literal>SELECT<many-to-many>"
#~ "</literal> n用多对多关联，你可以启用 join fetching，这"
#~ "不仅是对于集合本身，也对 <literal><many-to-many> 嵌套元素"
#~ "的属性。"

#~ msgid ""
#~ "<literal>unique (optional): enables the DDL generation of a "
#~ "unique constraint for the foreign-key column. This makes the association "
#~ "multiplicity effectively one-to-many."
#~ msgstr ""
#~ "<literal>unique（可选）：未外键字段启用唯一约束的 DDL 生成。这使"
#~ "得关联一对多的多样性更为有效。"

#~ msgid ""
#~ "<literal>not-found (optional - defaults to exception will treat a missing row as a null "
#~ "association."
#~ msgstr ""
#~ "<literal>not-found（可选 - 默认为 exceptionignore (optional): the name of a property of the "
#~ "associated class that is joined to this foreign key. If not specified, "
#~ "the primary key of the associated class is used."
#~ msgstr ""
#~ "<literal>property-ref（可选）：连接至这个外键的关联类的属性名"
#~ "称。如果未指定，关联类的主键将被使用。"

#~ msgid "Here are some examples."
#~ msgstr "下面是一些例子："

#~ msgid "A set of strings:"
#~ msgstr "一系列字符串："

#~ msgid ""
#~ "A bag containing integers with an iteration order determined by the "
#~ "<literal>order-by attribute:"
#~ msgstr ""
#~ "包含一组整数的 bag（还设置了 <literal>order-by 参数指定了迭代的"
#~ "顺序）： "

#~ msgid "An array of entities, in this case, a many-to-many association:"
#~ msgstr ""
#~ "一个实体数组，在这个案例中是一个多对多的关联（注意这里的实体是自动管理生命"
#~ "周期的对象（lifecycle objects），<literal>cascade=\"all\"）： "

#~ msgid "A map from string indices to dates:"
#~ msgstr "一个 map，通过字符串的索引来指明日期："

#~ msgid "A list of components (this is discussed in the next chapter):"
#~ msgstr "一个组件的列表：（将在下一章讨论）"

#~ msgid "One-to-many associations"
#~ msgstr "一对多关联（One-to-many Associations）"

#~ msgid ""
#~ "A <emphasis>one-to-many association links the tables of two "
#~ "classes via a foreign key with no intervening collection table. This "
#~ "mapping loses certain semantics of normal Java collections:"
#~ msgstr ""
#~ "<emphasis>一对多关联通过外键连接两个类对应"
#~ "的表，而没有中间集合表。 这个关系模型失去了一些 Java 集合的语义："

#~ msgid ""
#~ "The following example shows a map of <literal>Part entities by "
#~ "name, where <literal>partName is a persistent property of "
#~ "<literal>Part. Notice the use of a formula-based index:"
#~ msgstr ""
#~ "下面的例子展示一个 <literal>Part 实体的 map，把 name 作为关键"
#~ "字。（ <literal>partName 是 Part 的持久化属"
#~ "性）。注意其中的基于公式的索引的用法。 "

#~ msgid ""
#~ "Hibernate supports collections implementing <literal>java.util.SortedMapjava.util.SortedSet. You must specify a "
#~ "comparator in the mapping file:"
#~ msgstr ""
#~ "Hibernate 支持实现 <literal>java.util.SortedMap 和 "
#~ "<literal>java.util.SortedSet 的集合。你必须在映射文件中指定一个"
#~ "比较器："

#~ msgid ""
#~ "A final alternative is to use composite elements, which will be discussed "
#~ "later."
#~ msgstr "最后一种选择是使用复合元素，我们会在后面讨论。"

#~ msgid ""
#~ "Even more complex association mappings are covered in the next chapter."
#~ msgstr "甚至可能出现更加复杂的关联映射，我们会在下一章中列出所有可能性。 "

#~ msgid ""
#~ "<programlistingco>    </programlisting>   column_name (required): "
#~ "the name of the column holding the collection index values. </para>   base "
#~ "(optional - defaults to <literal>0): the value of the index "
#~ "column that corresponds to the first element of the list or array. </"
#~ "para> </callout>    "
#~ "<areaspec>    "
#~ "<programlisting></programlisting>   column (optional): the "
#~ "name of the column holding the collection index values. </para>   formula "
#~ "(optional): a SQL formula used to evaluate the key of the map. </para>   type "
#~ "(required): the type of the map keys. </para>      </programlisting>   column (optional): the name of the foreign "
#~ "key column for the collection index values. </para>   formula "
#~ "(optional): a SQ formula used to evaluate the foreign key of the map key. "
#~ "</para>    "
#~ "<literal>class (required): the entity class used as the map "
#~ "key. </para>   "
#~ msgstr ""
#~ "<programlistingco>    </programlisting>   column_name (required): "
#~ "the name of the column holding the collection index values. </para>   base "
#~ "(optional - defaults to <literal>0): the value of the index "
#~ "column that corresponds to the first element of the list or array. </"
#~ "para> </callout>    "
#~ "<areaspec>    "
#~ "<programlisting></programlisting>   column (optional): the "
#~ "name of the column holding the collection index values. </para>   formula "
#~ "(optional): a SQL formula used to evaluate the key of the map. </para>   type "
#~ "(required): the type of the map keys. </para>      </programlisting>   column (optional): the name of the foreign "
#~ "key column for the collection index values. </para>   formula "
#~ "(optional): a SQ formula used to evaluate the foreign key of the map key. "
#~ "</para>    "
#~ "<literal>class (required): the entity class used as the map "
#~ "key. </para>   "

#~ msgid ""
#~ "<programlistingco>   "
#~ "<area id=\"element2b\" coords=\"3 50\"/>  </programlisting>   "
#~ "<para> column (optional): the name of the column "
#~ "holding the collection element values. </para>   formula (optional): an "
#~ "SQL formula used to evaluate the element. </para>   type (required): the "
#~ "type of the collection element. </para>    A many-to-many association "
#~ "is specified using the <literal><many-to-many> element.       </programlisting>   column (optional): the name of the element "
#~ "foreign key column. </para>   "
#~ "<para> formula (optional): an SQL formula used to "
#~ "evaluate the element foreign key value. </para>   class (required): the "
#~ "name of the associated class. </para>   fetch (optional - defaults to "
#~ "<literal>join): enables outer-join or sequential select "
#~ "fetching for this association. This is a special case; for full eager "
#~ "fetching in a single <literal>SELECT of an entity and its many-"
#~ "to-many relationships to other entities, you would enable <literal>join nested element. "
#~ "</para>    "
#~ "<literal>unique (optional): enables the DDL generation of a "
#~ "unique constraint for the foreign-key column. This makes the association "
#~ "multiplicity effectively one-to-many. </para>   not-found (optional - "
#~ "defaults to <literal>exception): specifies how foreign keys "
#~ "that reference missing rows will be handled: <literal>ignore "
#~ "will treat a missing row as a null association. </para>  "
#~ "<callout arearefs=\"manytomany7\">  entity-name "
#~ "(optional): the entity name of the associated class, as an alternative to "
#~ "<literal>class.    property-ref (optional): the "
#~ "name of a property of the associated class that is joined to this foreign "
#~ "key. If not specified, the primary key of the associated class is used. </"
#~ "para> </callout>  "
#~ msgstr ""
#~ "<programlistingco>   "
#~ "<area id=\"element2b\" coords=\"3 50\"/>  </programlisting>   "
#~ "<para> column (optional): the name of the column "
#~ "holding the collection element values. </para>   formula (optional): an "
#~ "SQL formula used to evaluate the element. </para>   type (required): the "
#~ "type of the collection element. </para>    A many-to-many association "
#~ "is specified using the <literal><many-to-many> element.       </programlisting>   column (optional): the name of the element "
#~ "foreign key column. </para>   "
#~ "<para> formula (optional): an SQL formula used to "
#~ "evaluate the element foreign key value. </para>   class (required): the "
#~ "name of the associated class. </para>   fetch (optional - defaults to "
#~ "<literal>join): enables outer-join or sequential select "
#~ "fetching for this association. This is a special case; for full eager "
#~ "fetching in a single <literal>SELECT of an entity and its many-"
#~ "to-many relationships to other entities, you would enable <literal>join nested element. "
#~ "</para>    "
#~ "<literal>unique (optional): enables the DDL generation of a "
#~ "unique constraint for the foreign-key column. This makes the association "
#~ "multiplicity effectively one-to-many. </para>   not-found (optional - "
#~ "defaults to <literal>exception): specifies how foreign keys "
#~ "that reference missing rows will be handled: <literal>ignore "
#~ "will treat a missing row as a null association. </para>  "
#~ "<callout arearefs=\"manytomany7\">  entity-name "
#~ "(optional): the entity name of the associated class, as an alternative to "
#~ "<literal>class.    property-ref (optional): the "
#~ "name of a property of the associated class that is joined to this foreign "
#~ "key. If not specified, the primary key of the associated class is used. </"
#~ "para> </callout>  "

#~ msgid ""
#~ "<![CDATA["
#~ msgstr ""
#~ "<![CDATA["

#~ msgid ""
#~ "<![CDATA["
#~ msgstr ""
#~ "<![CDATA["

#~ msgid ""
#~ "<![CDATA["
#~ msgstr ""
#~ "<![CDATA["

#~ msgid ""
#~ "<![CDATA[