[jboss-cvs] JBossAS SVN: r96069 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Thu Nov 5 19:14:23 EST 2009
Author: xhuang at jboss.com
Date: 2009-11-05 19:14:23 -0500 (Thu, 05 Nov 2009)
New Revision: 96069
Modified:
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/best_practices.po
Log:
update
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po 2009-11-05 23:28:47 UTC (rev 96068)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po 2009-11-06 00:14:23 UTC (rev 96069)
@@ -7,7 +7,7 @@
"Project-Id-Version: basic_mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2009-11-05 10:29+1000\n"
+"PO-Revision-Date: 2009-11-06 10:07+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -30,26 +30,14 @@
#. Tag: para
#: basic_mapping.xml:34
#, no-c-format
-msgid ""
-"Object/relational mappings are usually defined in an XML document. The "
-"mapping document is designed to be readable and hand-editable. The mapping "
-"language is Java-centric, meaning that mappings are constructed around "
-"persistent class declarations and not table declarations."
-msgstr ""
-"对象和关系数据库之间的映射通常是用一个 XML 文档来定义的。这个"
-"映射文档被设计为易读的，并且可以手工修改。映射语言是以 Java 为中心，这意味着"
-"映射文档是按照持久化类的定义来创建的，而非表的定义。 "
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations and not table declarations."
+msgstr "对象和关系数据库之间的映射通常是用一个 XML 文档来定义的。这个映射文档被设计为易读的，并且可以手工修改。映射语言是以 Java 为中心，这意味着映射文档是按照持久化类的定义来创建的，而非表的定义。 "
#. Tag: para
#: basic_mapping.xml:41
#, no-c-format
-msgid ""
-"Please note that even though many Hibernate users choose to write the XML by "
-"hand, a number of tools exist to generate the mapping document. These "
-"include XDoclet, Middlegen and AndroMDA."
-msgstr ""
-"请注意，虽然很多 Hibernate 用户选择手写 XML 映射文档，但也有一些工具可以用来"
-"生成映射文档，包括 XDoclet、Middlegen 和 AndroMDA。"
+msgid "Please note that even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document. These include XDoclet, Middlegen and AndroMDA."
+msgstr "请注意，虽然很多 Hibernate 用户选择手写 XML 映射文档，但也有一些工具可以用来生成映射文档，包括 XDoclet、Middlegen 和 AndroMDA。"
#. Tag: para
#: basic_mapping.xml:47
@@ -194,17 +182,8 @@
#. Tag: para
#: basic_mapping.xml:53
#, no-c-format
-msgid ""
-"We will now discuss the content of the mapping document. We will only "
-"describe, however, the document elements and attributes that are used by "
-"Hibernate at runtime. The mapping document also contains some extra optional "
-"attributes and elements that affect the database schemas exported by the "
-"schema export tool (for example, the <literal> not-null</literal> attribute)."
-msgstr ""
-"我们现在开始讨论映射文档的内容。我们只描述 Hibernate 在运行时用到的文档元素和"
-"属性。映射文档还包括一些额外的可选属性和元素，它们在使用 schema 导出工具的时"
-"候会影响导出的数据库 schema 结果（比如，<literal>not-null</literal> 属"
-"性）。"
+msgid "We will now discuss the content of the mapping document. We will only describe, however, the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool (for example, the <literal> not-null</literal> attribute)."
+msgstr "我们现在开始讨论映射文档的内容。我们只描述 Hibernate 在运行时用到的文档元素和属性。映射文档还包括一些额外的可选属性和元素，它们在使用 schema 导出工具的时候会影响导出的数据库 schema 结果（比如，<literal>not-null</literal> 属性）。"
#. Tag: title
#: basic_mapping.xml:64
@@ -215,20 +194,8 @@
#. Tag: para
#: basic_mapping.xml:66
#, no-c-format
-msgid ""
-"All XML mappings should declare the doctype shown. The actual DTD can be "
-"found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/"
-"hibernate </literal>, or in <literal>hibernate3.jar</literal>. Hibernate "
-"will always look for the DTD in its classpath first. If you experience "
-"lookups of the DTD using an Internet connection, check the DTD declaration "
-"against the contents of your classpath."
-msgstr ""
-"所有的 XML 映射都需要定义如上所示的 doctype。DTD 可以从上述 URL 中获取，也可"
-"以从 <literal>hibernate-x.x.x/src/org/"
-"hibernate </literal> 目录中、或 "
-"<literal>hibernate.jar</literal> 文件中找到。Hibernate 总是会首先在它的 "
-"classptah 中搜索 DTD 文件。如果你发现它是通过连接 Internet 查找 DTD 文件，就"
-"对照你的 classpath 目录检查 XML 文件里的 DTD 声明。"
+msgid "All XML mappings should declare the doctype shown. The actual DTD can be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal>, or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check the DTD declaration against the contents of your classpath."
+msgstr "所有的 XML 映射都需要定义如上所示的 doctype。DTD 可以从上述 URL 中获取，也可以从 <literal>hibernate-x.x.x/src/org/hibernate </literal> 目录中、或 <literal>hibernate.jar</literal> 文件中找到。Hibernate 总是会首先在它的 classptah 中搜索 DTD 文件。如果你发现它是通过连接 Internet 查找 DTD 文件，就对照你的 classpath 目录检查 XML 文件里的 DTD 声明。"
#. Tag: title
#: basic_mapping.xml:76
@@ -239,44 +206,20 @@
#. Tag: para
#: basic_mapping.xml:77
#, no-c-format
-msgid ""
-"Hibernate will first attempt to resolve DTDs in its classpath. It does this "
-"is by registering a custom <literal>org.xml.sax.EntityResolver</literal> "
-"implementation with the SAXReader it uses to read in the xml files. This "
-"custom <literal>EntityResolver</literal> recognizes two different systemId "
-"namespaces:"
-msgstr ""
-"Hibernate 首先试图在其 classpath 中解析 DTD。这是依靠在系统中注册"
-"的 <literal>org.xml.sax.EntityResolver</literal> 的一个具体实现，SAXReader 依"
-"靠它来读取 xml 文件。这个自定义的 <literal>EntityResolver</literal> 能辨认两种不"
-"同的 systenId 命名空间："
+msgid "Hibernate will first attempt to resolve DTDs in its classpath. It does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces:"
+msgstr "Hibernate 首先试图在其 classpath 中解析 DTD。这是依靠在系统中注册的 <literal>org.xml.sax.EntityResolver</literal> 的一个具体实现，SAXReader 依靠它来读取 xml 文件。这个自定义的 <literal>EntityResolver</literal> 能辨认两种不同的 systenId 命名空间："
#. Tag: para
#: basic_mapping.xml:85
#, no-c-format
-msgid ""
-"a <literal>hibernate namespace</literal> is recognized whenever the resolver "
-"encounters a systemId starting with <literal>http://hibernate.sourceforge."
-"net/</literal>. The resolver attempts to resolve these entities via the "
-"classloader which loaded the Hibernate classes."
-msgstr ""
-"若 resolver 遇到了一个以 <literal>http://hibernate.sourceforge.net/</"
-"literal> 为开头的 systemId，它会辨认出是 <literal>hibernate namespace</"
-"literal>，resolver 就试图通过加载 Hibernate 类的 classloader 来查找这些实体。 "
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounters a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>. The resolver attempts to resolve these entities via the classloader which loaded the Hibernate classes."
+msgstr "若 resolver 遇到了一个以 <literal>http://hibernate.sourceforge.net/</literal> 为开头的 systemId，它会辨认出是 <literal>hibernate namespace</literal>，resolver 就试图通过加载 Hibernate 类的 classloader 来查找这些实体。 "
#. Tag: para
#: basic_mapping.xml:94
#, no-c-format
-msgid ""
-"a <literal>user namespace</literal> is recognized whenever the resolver "
-"encounters a systemId using a <literal>classpath://</literal> URL protocol. "
-"The resolver will attempt to resolve these entities via (1) the current "
-"thread context classloader and (2) the classloader which loaded the "
-"Hibernate classes."
-msgstr ""
-"若 resolver 遇到了一个使用 <literal>classpath://</literal> URL 协议的 "
-"systemId，它会辨认出这是 <literal>user namespace</literal>，resolver 试图通过"
-"（1) 当前线程上下文的 classloader 和（2) 加载 Hibernate class 的 classloader 来查找这些实体。"
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounters a systemId using a <literal>classpath://</literal> URL protocol. The resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr "若 resolver 遇到了一个使用 <literal>classpath://</literal> URL 协议的 systemId，它会辨认出这是 <literal>user namespace</literal>，resolver 试图通过（1) 当前线程上下文的 classloader 和（2) 加载 Hibernate class 的 classloader 来查找这些实体。"
#. Tag: para
#: basic_mapping.xml:103
@@ -323,14 +266,8 @@
#. Tag: para
#: basic_mapping.xml:107
#, no-c-format
-msgid ""
-"Where <literal>types.xml</literal> is a resource in the <literal>your."
-"domain</literal> package and contains a custom <xref linkend=\"mapping-types-"
-"custom\"/>."
-msgstr ""
-"这里的 <literal>types.xml</literal> 是 <literal>your.domain</literal> 包中的一个资"
-"源，它包含了一个自定义的 <xref linkend=\"mapping-types-"
-"custom\"/>。"
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\"/>."
+msgstr "这里的 <literal>types.xml</literal> 是 <literal>your.domain</literal> 包中的一个资源，它包含了一个自定义的 <xref linkend=\"mapping-types-custom\"/>。"
#. Tag: title
#: basic_mapping.xml:115
@@ -341,25 +278,8 @@
#. Tag: para
#: basic_mapping.xml:117
#, no-c-format
-msgid ""
-"This element has several optional attributes. The <literal>schema</literal> "
-"and <literal>catalog</literal> attributes specify that tables referred to in "
-"this mapping belong to the named schema and/or catalog. If they are "
-"specified, tablenames will be qualified by the given schema and catalog "
-"names. If they are missing, tablenames will be unqualified. The "
-"<literal>default-cascade</literal> attribute specifies what cascade style "
-"should be assumed for properties and collections that do not specify a "
-"<literal>cascade</literal> attribute. By default, the <literal>auto-import</"
-"literal> attribute allows you to use unqualified class names in the query "
-"language."
-msgstr ""
-"这个元素包括一些可选的属性。<literal>schema</literal> 和 <literal>catalog</"
-"literal> 属性， 指明了这个映射所连接（refer）的表所在的 schema 和/或 catalog "
-"名称。假若指定了这个属性，表名会加上所指定的 schema 和 catalog 的名字扩展为全"
-"限定名。假若没有指定，表名就不会使用全限定名。<literal>default-cascade</"
-"literal> 指定了未明确注明 <literal>cascade</literal> 属性的 Java 属性和 集合"
-"类 Hibernate 会采取什么样的默认级联风格。<literal>auto-import</literal> 属性"
-"默认让我们在查询语言中可以使用非全限定名的类名。"
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If they are specified, tablenames will be qualified by the given schema and catalog names. If they are missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections that do not specify a <literal>cascade</literal> attribute. By default, the <literal>auto-import</literal> attribute allows you to use unqualified class names in the query language."
+msgstr "这个元素包括一些可选的属性。<literal>schema</literal> 和 <literal>catalog</literal> 属性， 指明了这个映射所连接（refer）的表所在的 schema 和/或 catalog 名称。假若指定了这个属性，表名会加上所指定的 schema 和 catalog 的名字扩展为全限定名。假若没有指定，表名就不会使用全限定名。<literal>default-cascade</literal> 指定了未明确注明 <literal>cascade</literal> 属性的 Java 属性和 集合类 Hibernate 会采取什么样的默认级联风格。<literal>auto-import</literal> 属性默认让我们在查询语言中可以使用非全限定名的类名。"
#. Tag: programlisting
#: basic_mapping.xml:138
@@ -400,87 +320,44 @@
#. Tag: para
#: basic_mapping.xml:151
#, no-c-format
-msgid ""
-"<literal>default-cascade</literal> (optional - defaults to <literal>none</"
-"literal>): a default cascade style."
-msgstr ""
-"<literal>default-cascade</literal>（可选 — 默认为 <literal>none</literal>）："
-"默认的级联风格。 "
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): a default cascade style."
+msgstr "<literal>default-cascade</literal>（可选 — 默认为 <literal>none</literal>）：默认的级联风格。 "
#. Tag: para
#: basic_mapping.xml:157
#, no-c-format
-msgid ""
-"<literal>default-access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate should use for accessing all properties. "
-"It can be a custom implementation of <literal>PropertyAccessor</literal>."
-msgstr ""
-"<literal>default-access</literal>（可选 — 默认为 <literal>property</"
-"literal>）：Hibernate 用来访问所有属性的策略。可以通过实现 "
-"<literal>PropertyAccessor</literal> 接口自定义。 "
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate should use for accessing all properties. It can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr "<literal>default-access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问所有属性的策略。可以通过实现 <literal>PropertyAccessor</literal> 接口自定义。 "
#. Tag: para
#: basic_mapping.xml:164
#, no-c-format
-msgid ""
-"<literal>default-lazy</literal> (optional - defaults to <literal>true</"
-"literal>): the default value for unspecified <literal>lazy</literal> "
-"attributes of class and collection mappings."
-msgstr ""
-"<literal>default-lazy</literal>（可选 — 默认为 <literal>true</literal>）：指"
-"定了未明确注明 <literal>lazy</literal> 属性的 Java 属性和集合类，Hibernate 会"
-"采取什么样的默认加载风格。 "
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): the default value for unspecified <literal>lazy</literal> attributes of class and collection mappings."
+msgstr "<literal>default-lazy</literal>（可选 — 默认为 <literal>true</literal>）：指定了未明确注明 <literal>lazy</literal> 属性的 Java 属性和集合类，Hibernate 会采取什么样的默认加载风格。 "
#. Tag: para
#: basic_mapping.xml:171
#, no-c-format
-msgid ""
-"<literal>auto-import</literal> (optional - defaults to <literal>true</"
-"literal>): specifies whether we can use unqualified class names of classes "
-"in this mapping in the query language."
-msgstr ""
-"<literal>auto-import</literal>（可选 — 默认为 <literal>true</literal>）：指定"
-"我们是否可以在查询语言中使用非全限定的类名（仅限于本映射文件中的类）。 "
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): specifies whether we can use unqualified class names of classes in this mapping in the query language."
+msgstr "<literal>auto-import</literal>（可选 — 默认为 <literal>true</literal>）：指定我们是否可以在查询语言中使用非全限定的类名（仅限于本映射文件中的类）。 "
#. Tag: para
#: basic_mapping.xml:178
#, no-c-format
-msgid ""
-"<literal>package</literal> (optional): specifies a package prefix to use for "
-"unqualified class names in the mapping document."
-msgstr ""
-"<literal>package</literal>（可选）：指定一个包前缀，如果在映射文档中没有指定"
-"全限定的类名，就使用这个作为包名。 "
+msgid "<literal>package</literal> (optional): specifies a package prefix to use for unqualified class names in the mapping document."
+msgstr "<literal>package</literal>（可选）：指定一个包前缀，如果在映射文档中没有指定全限定的类名，就使用这个作为包名。 "
#. Tag: para
#: basic_mapping.xml:186
#, no-c-format
-msgid ""
-"If you have two persistent classes with the same unqualified name, you "
-"should set <literal>auto-import=\"false\"</literal>. An exception will "
-"result if you attempt to assign two classes to the same \"imported\" name."
-msgstr ""
-"假若你有两个持久化类，它们的非全限定名是一样的（就是两个类的名字一样，所在的"
-"包不一样 — 译者注），你应该设置 <literal>auto-import=\"false\"</literal>。如"
-"果你把一个“导入过”的名字同时对应两个类，Hibernate 会抛出一个异常。"
+msgid "If you have two persistent classes with the same unqualified name, you should set <literal>auto-import=\"false\"</literal>. An exception will result if you attempt to assign two classes to the same \"imported\" name."
+msgstr "假若你有两个持久化类，它们的非全限定名是一样的（就是两个类的名字一样，所在的包不一样 — 译者注），你应该设置 <literal>auto-import=\"false\"</literal>。如果你把一个“导入过”的名字同时对应两个类，Hibernate 会抛出一个异常。"
#. Tag: para
#: basic_mapping.xml:192
#, no-c-format
-msgid ""
-"The <literal>hibernate-mapping</literal> element allows you to nest several "
-"persistent <literal><class></literal> mappings, as shown above. It is, "
-"however, good practice (and expected by some tools) to map only a single "
-"persistent class, or a single class hierarchy, in one mapping file and name "
-"it after the persistent superclass. For example, <literal>Cat.hbm.xml</"
-"literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, "
-"<literal>Animal.hbm.xml</literal>."
-msgstr ""
-"注意 <literal>hibernate-mapping</literal> 元素允许你嵌套多个如上所示的 "
-"<literal><class></literal> 映射。但是最好的做法（也许一些工具需要的）是"
-"一个持久化类（或一个类的继承层次）对应一个映射文件，并以持久化的超类名称命"
-"名，例如：<literal>Cat.hbm.xml</literal>、<literal>Dog.hbm.xml</literal>，或"
-"者如果使用继承，<literal>Animal.hbm.xml</literal>。"
+msgid "The <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal><class></literal> mappings, as shown above. It is, however, good practice (and expected by some tools) to map only a single persistent class, or a single class hierarchy, in one mapping file and name it after the persistent superclass. For example, <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr "注意 <literal>hibernate-mapping</literal> 元素允许你嵌套多个如上所示的 <literal><class></literal> 映射。但是最好的做法（也许一些工具需要的）是一个持久化类（或一个类的继承层次）对应一个映射文件，并以持久化的超类名称命名，例如：<literal>Cat.hbm.xml</literal>、<literal>Dog.hbm.xml</literal>，或者如果使用继承，<literal>Animal.hbm.xml</literal>。"
#. Tag: title
#: basic_mapping.xml:205
@@ -491,9 +368,7 @@
#. Tag: para
#: basic_mapping.xml:207
#, no-c-format
-msgid ""
-"You can declare a persistent class using the <literal>class</literal> "
-"element. For example:"
+msgid "You can declare a persistent class using the <literal>class</literal> element. For example:"
msgstr "你可以使用 <literal>class</literal> 元素来定义一个持久化类。例如："
#. Tag: programlisting
@@ -553,366 +428,177 @@
#. Tag: para
#: basic_mapping.xml:238
#, no-c-format
-msgid ""
-"<literal>name</literal> (optional): the fully qualified Java class name of "
-"the persistent class or interface. If this attribute is missing, it is "
-"assumed that the mapping is for a non-POJO entity."
-msgstr ""
-"<literal>name</literal>（可选）：持久化类（或者接口）的 Java 全限定名。 如果"
-"这个属性不存在，Hibernate 将假定这是一个非 POJO 的实体映射。 "
+msgid "<literal>name</literal> (optional): the fully qualified Java class name of the persistent class or interface. If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr "<literal>name</literal>（可选）：持久化类（或者接口）的 Java 全限定名。 如果这个属性不存在，Hibernate 将假定这是一个非 POJO 的实体映射。 "
#. Tag: para
#: basic_mapping.xml:245
#, no-c-format
-msgid ""
-"<literal>table</literal> (optional - defaults to the unqualified class "
-"name): the name of its database table."
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): the name of its database table."
msgstr "<literal>table</literal>（可选 — 默认是类的非全限定名）：对应的数据库表名。 "
#. Tag: para
#: basic_mapping.xml:251
#, no-c-format
-msgid ""
-"<literal>discriminator-value</literal> (optional - defaults to the class "
-"name): a value that distinguishes individual subclasses that is used for "
-"polymorphic behavior. Acceptable values include <literal>null</literal> and "
-"<literal>not null</literal>."
-msgstr ""
-"<literal>discriminator-value</literal>（可选 — 默认和类名一样）：一个用于区分"
-"不同的子类的值，在多态行为时使用。它可以接受的值包括 <literal>null</literal> "
-"和 <literal>not null</literal>。 "
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): a value that distinguishes individual subclasses that is used for polymorphic behavior. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr "<literal>discriminator-value</literal>（可选 — 默认和类名一样）：一个用于区分不同的子类的值，在多态行为时使用。它可以接受的值包括 <literal>null</literal> 和 <literal>not null</literal>。 "
#. Tag: para
#: basic_mapping.xml:258
#, no-c-format
-msgid ""
-"<literal>mutable</literal> (optional - defaults to <literal>true</literal>): "
-"specifies that instances of the class are (not) mutable."
-msgstr ""
-"<literal>mutable</literal>（可选，默认值为 <literal>true</literal>）：表明该"
-"类的实例是可变的或者不可变的。 "
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): specifies that instances of the class are (not) mutable."
+msgstr "<literal>mutable</literal>（可选，默认值为 <literal>true</literal>）：表明该类的实例是可变的或者不可变的。 "
#. Tag: para
-#: basic_mapping.xml:264 basic_mapping.xml:2227
+#: basic_mapping.xml:264
+#: basic_mapping.xml:2227
#, no-c-format
-msgid ""
-"<literal>schema</literal> (optional): overrides the schema name specified by "
-"the root <literal><hibernate-mapping></literal> element."
-msgstr ""
-"<literal>schema</literal>（可选）：覆盖在根 <literal><hibernate-"
-"mapping></literal> 元素中指定的 schema 名字。 "
+msgid "<literal>schema</literal> (optional): overrides the schema name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>schema</literal>（可选）：覆盖在根 <literal><hibernate-mapping></literal> 元素中指定的 schema 名字。 "
#. Tag: para
-#: basic_mapping.xml:270 basic_mapping.xml:2233
+#: basic_mapping.xml:270
+#: basic_mapping.xml:2233
#, no-c-format
-msgid ""
-"<literal>catalog</literal> (optional): overrides the catalog name specified "
-"by the root <literal><hibernate-mapping></literal> element."
-msgstr ""
-"<literal>catalog</literal>（可选）：覆盖在根 <literal><hibernate-"
-"mapping></literal> 元素中指定的 catalog 名字。 "
+msgid "<literal>catalog</literal> (optional): overrides the catalog name specified by the root <literal><hibernate-mapping></literal> element."
+msgstr "<literal>catalog</literal>（可选）：覆盖在根 <literal><hibernate-mapping></literal> 元素中指定的 catalog 名字。 "
#. Tag: para
#: basic_mapping.xml:276
#, no-c-format
-msgid ""
-"<literal>proxy</literal> (optional): specifies an interface to use for lazy "
-"initializing proxies. You can specify the name of the class itself."
+msgid "<literal>proxy</literal> (optional): specifies an interface to use for lazy initializing proxies. You can specify the name of the class itself."
msgstr "<literal>proxy</literal>（可选）：指定一个接口，在延迟装载时作为代理使用。你可以在这里使用该类自己的名字。 "
#. Tag: para
#: basic_mapping.xml:282
#, no-c-format
-msgid ""
-"<literal>dynamic-update</literal> (optional - defaults to <literal>false</"
-"literal>): specifies that <literal>UPDATE</literal> SQL should be generated "
-"at runtime and can contain only those columns whose values have changed."
-msgstr ""
-"<literal>dynamic-update</literal>（可选，默认为 <literal>false</literal>）："
-"指定用于 <literal>UPDATE</literal> 的 SQL 将会在运行时动态生成，并且只更新那"
-"些改变过的字段。 "
+msgid "<literal>dynamic-update</literal> (optional - defaults to <literal>false</literal>): specifies that <literal>UPDATE</literal> SQL should be generated at runtime and can contain only those columns whose values have changed."
+msgstr "<literal>dynamic-update</literal>（可选，默认为 <literal>false</literal>）：指定用于 <literal>UPDATE</literal> 的 SQL 将会在运行时动态生成，并且只更新那些改变过的字段。 "
#. Tag: para
#: basic_mapping.xml:289
#, no-c-format
-msgid ""
-"<literal>dynamic-insert</literal> (optional - defaults to <literal>false</"
-"literal>): specifies that <literal>INSERT</literal> SQL should be generated "
-"at runtime and contain only the columns whose values are not null."
-msgstr ""
-"<literal>dynamic-insert</literal>（可选，默认为 <literal>false</literal>）："
-"指定用于 <literal>INSERT</literal> 的 SQL 将会在运行时动态生成，并且只包含那"
-"些非空值字段。 "
+msgid "<literal>dynamic-insert</literal> (optional - defaults to <literal>false</literal>): specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr "<literal>dynamic-insert</literal>（可选，默认为 <literal>false</literal>）：指定用于 <literal>INSERT</literal> 的 SQL 将会在运行时动态生成，并且只包含那些非空值字段。 "
#. Tag: para
#: basic_mapping.xml:296
#, no-c-format
-msgid ""
-"<literal>select-before-update</literal> (optional - defaults to "
-"<literal>false</literal>): specifies that Hibernate should <emphasis>never</"
-"emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that "
-"an object is actually modified. Only when a transient object has been "
-"associated with a new session using <literal>update()</literal>, will "
-"Hibernate perform an extra SQL <literal>SELECT</literal> to determine if an "
-"<literal>UPDATE</literal> is actually required."
-msgstr ""
-"<literal>select-before-update</literal>（可选，默认为 <literal>false</"
-"literal>）：指定 Hibernate 除非确定对象真正被修改了（如果该值为 true — 译"
-"注），否则<emphasis>不会</emphasis>执行 SQL <literal>UPDATE</literal> 操作。"
-"在特定场合（实际上，它只在一个瞬时对象（transient object）关联到一个新的 "
-"session 中时执行的 update() 中生效），这说明 Hibernate 会在 <literal>UPDATE</"
-"literal> 之前执行一次额外的 SQL <literal>SELECT</literal> 操作来决定是否确实需要执行 <literal>UPDATE</literal>。"
+msgid "<literal>select-before-update</literal> (optional - defaults to <literal>false</literal>): specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. Only when a transient object has been associated with a new session using <literal>update()</literal>, will Hibernate perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr "<literal>select-before-update</literal>（可选，默认为 <literal>false</literal>）：指定 Hibernate 除非确定对象真正被修改了（如果该值为 true — 译注），否则<emphasis>不会</emphasis>执行 SQL <literal>UPDATE</literal> 操作。在特定场合（实际上，它只在一个瞬时对象（transient object）关联到一个新的 session 中时执行的 update() 中生效），这说明 Hibernate 会在 <literal>UPDATE</literal> 之前执行一次额外的 SQL <literal>SELECT</literal> 操作来决定是否确实需要执行 <literal>UPDATE</literal>。"
#. Tag: para
#: basic_mapping.xml:306
#, no-c-format
-msgid ""
-"<literal>polymorphism</literal> (optional - defaults to <literal>implicit</"
-"literal>): determines whether implicit or explicit query polymorphism is "
-"used."
-msgstr ""
-"<literal>polymorphism（多态）</literal>（可选，默认值为 <literal>implicit "
-"（隐式）</literal>）：界定是隐式还是显式的使用多态查询（这只在 Hibernate 的具"
-"体表继承策略中用到 — 译注）。 "
+msgid "<literal>polymorphism</literal> (optional - defaults to <literal>implicit</literal>): determines whether implicit or explicit query polymorphism is used."
+msgstr "<literal>polymorphism（多态）</literal>（可选，默认值为 <literal>implicit （隐式）</literal>）：界定是隐式还是显式的使用多态查询（这只在 Hibernate 的具体表继承策略中用到 — 译注）。 "
#. Tag: para
#: basic_mapping.xml:312
#, no-c-format
-msgid ""
-"<literal>where</literal> (optional): specifies an arbitrary SQL "
-"<literal>WHERE</literal> condition to be used when retrieving objects of "
-"this class."
-msgstr ""
-"<literal>where</literal>（可选）指定一个附加的 SQL <literal>WHERE</literal> "
-"条件，在抓取这个类的对象时会一直增加这个条件。 "
+msgid "<literal>where</literal> (optional): specifies an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class."
+msgstr "<literal>where</literal>（可选）指定一个附加的 SQL <literal>WHERE</literal> 条件，在抓取这个类的对象时会一直增加这个条件。 "
#. Tag: para
#: basic_mapping.xml:318
#, no-c-format
-msgid ""
-"<literal>persister</literal> (optional): specifies a custom "
-"<literal>ClassPersister</literal>."
-msgstr ""
-"<literal>persister</literal>（可选）：指定一个定制的 "
-"<literal>ClassPersister</literal>。 "
+msgid "<literal>persister</literal> (optional): specifies a custom <literal>ClassPersister</literal>."
+msgstr "<literal>persister</literal>（可选）：指定一个定制的 <literal>ClassPersister</literal>。 "
#. Tag: para
#: basic_mapping.xml:323
#, no-c-format
-msgid ""
-"<literal>batch-size</literal> (optional - defaults to <literal>1</literal>): "
-"specifies a \"batch size\" for fetching instances of this class by "
-"identifier."
-msgstr ""
-"<literal>batch-size</literal>（可选,默认是 <literal>1</literal>）指定一个用"
-"于 根据标识符（identifier）抓取实例时使用的 \"batch size\"（批次抓取数量）。 "
+msgid "<literal>batch-size</literal> (optional - defaults to <literal>1</literal>): specifies a \"batch size\" for fetching instances of this class by identifier."
+msgstr "<literal>batch-size</literal>（可选,默认是 <literal>1</literal>）指定一个用于 根据标识符（identifier）抓取实例时使用的 \"batch size\"（批次抓取数量）。 "
#. Tag: para
#: basic_mapping.xml:329
#, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>version</"
-"literal>): determines the optimistic locking strategy."
-msgstr ""
-"<literal>optimistic-lock（乐观锁定）</literal>（可选，默认是 "
-"<literal>version</literal>）：决定乐观锁定的策略。 "
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>version</literal>): determines the optimistic locking strategy."
+msgstr "<literal>optimistic-lock（乐观锁定）</literal>（可选，默认是 <literal>version</literal>）：决定乐观锁定的策略。 "
#. Tag: para
#: basic_mapping.xml:335
#, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional): lazy fetching can be disabled by setting "
-"<literal>lazy=\"false\"</literal>."
-msgstr ""
-"<literal>lazy</literal>（可选）：通过设置 <literal>lazy=\"false\"</"
-"literal>，所有的延迟加载（Lazy fetching）功能将被全部禁用（disabled）。"
+msgid "<literal>lazy</literal> (optional): lazy fetching can be disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr "<literal>lazy</literal>（可选）：通过设置 <literal>lazy=\"false\"</literal>，所有的延迟加载（Lazy fetching）功能将被全部禁用（disabled）。"
#. Tag: para
#: basic_mapping.xml:341
#, no-c-format
-msgid ""
-"<literal>entity-name</literal> (optional - defaults to the class name): "
-"Hibernate3 allows a class to be mapped multiple times, potentially to "
-"different tables. It also allows entity mappings that are represented by "
-"Maps or XML at the Java level. In these cases, you should provide an "
-"explicit arbitrary name for the entity. See <xref linkend=\"persistent-"
-"classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
-msgstr ""
-"<literal>entity-name</literal>（可选，默认为类名）：Hibernate3 允许一个类进行"
-"多次映射（前提是映射到不同的表），并且允许使用 Maps 或 XML 代替 Java 层次的实"
-"体映射（也就是实现动态领域模型，不用写持久化类－译注）。更多信息请看 <xref linkend=\"persistent-"
-"classes-dynamicmodels\"/> 和 <xref linkend=\"xml\"/>。"
+msgid "<literal>entity-name</literal> (optional - defaults to the class name): Hibernate3 allows a class to be mapped multiple times, potentially to different tables. It also allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\"/> and <xref linkend=\"xml\"/> for more information."
+msgstr "<literal>entity-name</literal>（可选，默认为类名）：Hibernate3 允许一个类进行多次映射（前提是映射到不同的表），并且允许使用 Maps 或 XML 代替 Java 层次的实体映射（也就是实现动态领域模型，不用写持久化类－译注）。更多信息请看 <xref linkend=\"persistent-classes-dynamicmodels\"/> 和 <xref linkend=\"xml\"/>。"
#. Tag: para
#: basic_mapping.xml:351
#, no-c-format
-msgid ""
-"<literal>check</literal> (optional): an SQL expression used to generate a "
-"multi-row <emphasis>check</emphasis> constraint for automatic schema "
-"generation."
-msgstr ""
-"<literal>check</literal>（可选）：这是一个 SQL 表达式， 用于为自动生成的 "
-"schema 添加多行（multi-row）约束<emphasis>检查</emphasis>。 "
+msgid "<literal>check</literal> (optional): an SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr "<literal>check</literal>（可选）：这是一个 SQL 表达式， 用于为自动生成的 schema 添加多行（multi-row）约束<emphasis>检查</emphasis>。 "
#. Tag: para
#: basic_mapping.xml:357
#, no-c-format
-msgid ""
-"<literal>rowid</literal> (optional): Hibernate can use ROWIDs on databases. "
-"On Oracle, for example, Hibernate can use the <literal>rowid</literal> extra "
-"column for fast updates once this option has been set to <literal>rowid</"
-"literal>. A ROWID is an implementation detail and represents the physical "
-"location of a stored tuple."
-msgstr ""
-"<literal>rowid</literal>（可选）：Hibernate 可以使用数据库支持的所谓的 "
-"ROWIDs，例如：Oracle 数据库，如果你设置这个可选的 <literal>rowid</literal>，"
-"Hibernate 可以使用额外的字段 <literal>rowid</literal> 实现快速更新。ROWID 是"
-"这个功能实现的重点，它代表了一个存储元组（tuple）的物理位置。 "
+msgid "<literal>rowid</literal> (optional): Hibernate can use ROWIDs on databases. On Oracle, for example, Hibernate can use the <literal>rowid</literal> extra column for fast updates once this option has been set to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr "<literal>rowid</literal>（可选）：Hibernate 可以使用数据库支持的所谓的 ROWIDs，例如：Oracle 数据库，如果你设置这个可选的 <literal>rowid</literal>，Hibernate 可以使用额外的字段 <literal>rowid</literal> 实现快速更新。ROWID 是这个功能实现的重点，它代表了一个存储元组（tuple）的物理位置。 "
#. Tag: para
#: basic_mapping.xml:364
#, no-c-format
-msgid ""
-"<literal>subselect</literal> (optional): maps an immutable and read-only "
-"entity to a database subselect. This is useful if you want to have a view "
-"instead of a base table. See below for more information."
-msgstr ""
-"<literal>subselect</literal>（可选）：它将一个不可变（immutable）并且只读的实"
-"体映射到一个数据库的子查询中。当你想用视图代替一张基本表的时候，这是有用的，"
-"但最好不要这样做。更多的介绍请看下面内容。 "
+msgid "<literal>subselect</literal> (optional): maps an immutable and read-only entity to a database subselect. This is useful if you want to have a view instead of a base table. See below for more information."
+msgstr "<literal>subselect</literal>（可选）：它将一个不可变（immutable）并且只读的实体映射到一个数据库的子查询中。当你想用视图代替一张基本表的时候，这是有用的，但最好不要这样做。更多的介绍请看下面内容。 "
#. Tag: para
#: basic_mapping.xml:371
#, no-c-format
-msgid ""
-"<literal>abstract</literal> (optional): is used to mark abstract "
-"superclasses in <literal><union-subclass></literal> hierarchies."
-msgstr ""
-"<literal>abstract</literal>（可选）：用于在 <literal><union-subclass></"
-"literal> 的层次结构（hierarchies）中标识抽象超类。"
+msgid "<literal>abstract</literal> (optional): is used to mark abstract superclasses in <literal><union-subclass></literal> hierarchies."
+msgstr "<literal>abstract</literal>（可选）：用于在 <literal><union-subclass></literal> 的层次结构（hierarchies）中标识抽象超类。"
#. Tag: para
#: basic_mapping.xml:379
#, no-c-format
-msgid ""
-"It is acceptable for the named persistent class to be an interface. You can "
-"declare implementing classes of that interface using the <literal><"
-"subclass></literal> element. You can persist any <emphasis>static</"
-"emphasis> inner class. Specify the class name using the standard form i.e. "
-"<literal>e.g.Foo$Bar</literal>."
-msgstr ""
-"若指明的持久化类实际上是一个接口，这也是完全可以接受的。之后你可以用元素 "
-"<literal><subclass></literal> 来指定该接口的实际实现类。你可以持久化任"
-"何 <emphasis>static</emphasis>（静态的）内部类。你应该使用标准的类名格式来指"
-"定类名，比如：<literal>Foo$Bar</literal>。"
+msgid "It is acceptable for the named persistent class to be an interface. You can declare implementing classes of that interface using the <literal><subclass></literal> element. You can persist any <emphasis>static</emphasis> inner class. Specify the class name using the standard form i.e. <literal>e.g.Foo$Bar</literal>."
+msgstr "若指明的持久化类实际上是一个接口，这也是完全可以接受的。之后你可以用元素 <literal><subclass></literal> 来指定该接口的实际实现类。你可以持久化任何 <emphasis>static</emphasis>（静态的）内部类。你应该使用标准的类名格式来指定类名，比如：<literal>Foo$Bar</literal>。"
#. Tag: para
#: basic_mapping.xml:386
#, no-c-format
-msgid ""
-"Immutable classes, <literal>mutable=\"false\"</literal>, cannot be updated "
-"or deleted by the application. This allows Hibernate to make some minor "
-"performance optimizations."
-msgstr ""
-"不可变类，<literal>mutable=\"false\"</literal> 不可以被应用程序更新或者删"
-"除。这允许 Hibernate 实现一些小小的性能优化。"
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, cannot be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr "不可变类，<literal>mutable=\"false\"</literal> 不可以被应用程序更新或者删除。这允许 Hibernate 实现一些小小的性能优化。"
#. Tag: para
#: basic_mapping.xml:391
#, no-c-format
-msgid ""
-"The optional <literal>proxy</literal> attribute enables lazy initialization "
-"of persistent instances of the class. Hibernate will initially return CGLIB "
-"proxies that implement the named interface. The persistent object will load "
-"when a method of the proxy is invoked. See \"Initializing collections and "
-"proxies\" below."
-msgstr ""
-"可选的 <literal>proxy</literal> 属性允许延迟加载类的持久化实例。Hibernate 开"
-"始会返回实现了这个命名接口的 CGLIB 代理。当代理的某个方法被实际调用的时候，真"
-"实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。 "
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies that implement the named interface. The persistent object will load when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr "可选的 <literal>proxy</literal> 属性允许延迟加载类的持久化实例。Hibernate 开始会返回实现了这个命名接口的 CGLIB 代理。当代理的某个方法被实际调用的时候，真实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。 "
#. Tag: para
#: basic_mapping.xml:398
#, no-c-format
-msgid ""
-"<emphasis>Implicit</emphasis> polymorphism means that instances of the class "
-"will be returned by a query that names any superclass or implemented "
-"interface or class, and that instances of any subclass of the class will be "
-"returned by a query that names the class itself. <emphasis>Explicit</"
-"emphasis> polymorphism means that class instances will be returned only by "
-"queries that explicitly name that class. Queries that name the class will "
-"return only instances of subclasses mapped inside this <literal><class>"
-"</literal> declaration as a <literal><subclass></literal> or "
-"<literal><joined-subclass></literal>. For most purposes, the default "
-"<literal>polymorphism=\"implicit\"</literal> is appropriate. Explicit "
-"polymorphism is useful when two different classes are mapped to the same "
-"table This allows a \"lightweight\" class that contains a subset of the "
-"table columns."
-msgstr ""
-"<emphasis>Implicit</emphasis>（隐式）的多态是指，如果查询时给出的是任何超类、"
-"该类实现的接口或者该类的名字，都会返回这个类的实例；如果查询中给出的是子类的"
-"名字，则会返回子类的实例。<emphasis>Explicit</emphasis>（显式）的多态是指，只"
-"有在查询时给出明确的该类名字时才会返回这个类的实例； 同时只有在这个 "
-"<literal><class></literal> 的定义中作为 <literal><subclass></"
-"literal> 或者 <literal><joined-subclass></literal> 出现的子类，才会可能"
-"返回。在大多数情况下，默认的 <literal>polymorphism=\"implicit\"</literal> 都"
-"是合适的。显式的多态在有两个不同的类映射到同一个表的时候很有用。（允许一个“轻"
-"量级”的类，只包含部分表字段）。 "
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or class, and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class. Queries that name the class will return only instances of subclasses mapped inside this <literal><class></literal> declaration as a <literal><subclass></literal> or <literal><joined-subclass></literal>. For most purposes, the default <literal>polymorphism=\"implicit\"</literal> is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table This allows a \"lightweight\" class that contains a subset of the table columns."
+msgstr "<emphasis>Implicit</emphasis>（隐式）的多态是指，如果查询时给出的是任何超类、该类实现的接口或者该类的名字，都会返回这个类的实例；如果查询中给出的是子类的名字，则会返回子类的实例。<emphasis>Explicit</emphasis>（显式）的多态是指，只有在查询时给出明确的该类名字时才会返回这个类的实例； 同时只有在这个 <literal><class></literal> 的定义中作为 <literal><subclass></literal> 或者 <literal><joined-subclass></literal> 出现的子类，才会可能返回。在大多数情况下，默认的 <literal>polymorphism=\"implicit\"</literal> 都是合适的。显式的多态在有两个不同的类映射到同一个表的时候很有用。（允许一个“轻量级”的类，只包含部分表字段）。 "
#. Tag: para
#: basic_mapping.xml:410
#, no-c-format
-msgid ""
-"The <literal>persister</literal> attribute lets you customize the "
-"persistence strategy used for the class. You can, for example, specify your "
-"own subclass of <literal>org.hibernate.persister.EntityPersister</literal>, "
-"or you can even provide a completely new implementation of the interface "
-"<literal>org.hibernate.persister.ClassPersister</literal> that implements, "
-"for example, persistence via stored procedure calls, serialization to flat "
-"files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for "
-"a simple example of \"persistence\" to a <literal>Hashtable</literal>."
-msgstr ""
-"<literal>persister</literal> 属性可以让你定制这个类使用的持久化策略。你可以指"
-"定你自己实现 <literal>org.hibernate.persister.EntityPersister</literal> 的子"
-"类，你甚至可以完全从头开始编写一个 <literal>org.hibernate.persister."
-"ClassPersister</literal> 接口的实现，比如是用储存过程调用、序列化到文件或者 "
-"LDAP 数据库来实现。参阅 <literal>org.hibernate.test.CustomPersister</"
-"literal>，这是持久化到 <literal>Hashtable</literal> 的一个简单例子。 "
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You can, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal>, or you can even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements, for example, persistence via stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example of \"persistence\" to a <literal>Hashtable</literal>."
+msgstr "<literal>persister</literal> 属性可以让你定制这个类使用的持久化策略。你可以指定你自己实现 <literal>org.hibernate.persister.EntityPersister</literal> 的子类，你甚至可以完全从头开始编写一个 <literal>org.hibernate.persister.ClassPersister</literal> 接口的实现，比如是用储存过程调用、序列化到文件或者 LDAP 数据库来实现。参阅 <literal>org.hibernate.test.CustomPersister</literal>，这是持久化到 <literal>Hashtable</literal> 的一个简单例子。 "
#. Tag: para
#: basic_mapping.xml:421
#, no-c-format
-msgid ""
-"The <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> "
-"settings are not inherited by subclasses, so they can also be specified on "
-"the <literal><subclass></literal> or <literal><joined-subclass></"
-"literal> elements. Although these settings can increase performance in some "
-"cases, they can actually decrease performance in others."
-msgstr ""
-"请注意 <literal>dynamic-update</literal> 和 <literal>dynamic-insert</"
-"literal> 的设置并不会继承到子类，所以在 <literal><subclass></literal> "
-"或者 <literal><joined-subclass></literal> 元素中可能需要再次设置。这些"
-"设置在某些情况下能够提高效率，而其他情况下则反而可能降低性能。"
+msgid "The <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses, so they can also be specified on the <literal><subclass></literal> or <literal><joined-subclass></literal> elements. Although these settings can increase performance in some cases, they can actually decrease performance in others."
+msgstr "请注意 <literal>dynamic-update</literal> 和 <literal>dynamic-insert</literal> 的设置并不会继承到子类，所以在 <literal><subclass></literal> 或者 <literal><joined-subclass></literal> 元素中可能需要再次设置。这些设置在某些情况下能够提高效率，而其他情况下则反而可能降低性能。"
#. Tag: para
#: basic_mapping.xml:429
#, no-c-format
-msgid ""
-"Use of <literal>select-before-update</literal> will usually decrease "
-"performance. It is useful to prevent a database update trigger being called "
-"unnecessarily if you reattach a graph of detached instances to a "
-"<literal>Session</literal>."
-msgstr ""
-"使用 <literal>select-before-update</literal> 通常会降低性能。如果你重新连接一"
-"个脱管（detached）对象实例 到一个 <literal>Session</literal> 中时，它可以防止"
-"数据库不必要的触发 update。这就很有用了。"
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr "使用 <literal>select-before-update</literal> 通常会降低性能。如果你重新连接一个脱管（detached）对象实例 到一个 <literal>Session</literal> 中时，它可以防止数据库不必要的触发 update。这就很有用了。"
#. Tag: para
#: basic_mapping.xml:435
#, no-c-format
-msgid ""
-"If you enable <literal>dynamic-update</literal>, you will have a choice of "
-"optimistic locking strategies:"
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
msgstr "如果你打开了<literal>dynamic-update</literal>，你可以选择几种乐观锁定的策略："
#. Tag: para
@@ -930,9 +616,7 @@
#. Tag: para
#: basic_mapping.xml:451
#, no-c-format
-msgid ""
-"<literal>dirty</literal>: check the changed columns, allowing some "
-"concurrent updates"
+msgid "<literal>dirty</literal>: check the changed columns, allowing some concurrent updates"
msgstr "<literal>dirty（脏检查）</literal>：只检察修改过的字段，允许某些并行更新"
#. Tag: para
@@ -944,31 +628,14 @@
#. Tag: para
#: basic_mapping.xml:461
#, no-c-format
-msgid ""
-"It is <emphasis>strongly</emphasis> recommended that you use version/"
-"timestamp columns for optimistic locking with Hibernate. This strategy "
-"optimizes performance and correctly handles modifications made to detached "
-"instances (i.e. when <literal>Session.merge()</literal> is used)."
-msgstr ""
-"我们<emphasis>强烈</emphasis>建议你在 Hibernate 中使用 version/timestamp "
-"字段来进行乐观锁定。这个选择可以优化性能，且能够处理对脱管实例的修改（例如：在使用 <literal>Session.merge()</literal> 的"
-"时候）。"
+msgid "It is <emphasis>strongly</emphasis> recommended that you use version/timestamp columns for optimistic locking with Hibernate. This strategy optimizes performance and correctly handles modifications made to detached instances (i.e. when <literal>Session.merge()</literal> is used)."
+msgstr "我们<emphasis>强烈</emphasis>建议你在 Hibernate 中使用 version/timestamp 字段来进行乐观锁定。这个选择可以优化性能，且能够处理对脱管实例的修改（例如：在使用 <literal>Session.merge()</literal> 的时候）。"
#. Tag: para
#: basic_mapping.xml:468
#, no-c-format
-msgid ""
-"There is no difference between a view and a base table for a Hibernate "
-"mapping. This is transparent at the database level, although some DBMS do "
-"not support views properly, especially with updates. Sometimes you want to "
-"use a view, but you cannot create one in the database (i.e. with a legacy "
-"schema). In this case, you can map an immutable and read-only entity to a "
-"given SQL subselect expression:"
-msgstr ""
-"对 Hibernate 映射来说视图和表是没有区别的，这是因为它们在数据层都是透明的"
-"（ 注意：一些数据库不支持视图属性，特别是更新的时候）。有时你想使用视图，但却"
-"不能在数据库中创建它（例如：在遗留的 schema 中）。这样的话，你可以映射一个不"
-"可变的（immutable）并且是 只读的实体到一个给定的 SQL 子查询表达式： "
+msgid "There is no difference between a view and a base table for a Hibernate mapping. This is transparent at the database level, although some DBMS do not support views properly, especially with updates. Sometimes you want to use a view, but you cannot create one in the database (i.e. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr "对 Hibernate 映射来说视图和表是没有区别的，这是因为它们在数据层都是透明的（ 注意：一些数据库不支持视图属性，特别是更新的时候）。有时你想使用视图，但却不能在数据库中创建它（例如：在遗留的 schema 中）。这样的话，你可以映射一个不可变的（immutable）并且是 只读的实体到一个给定的 SQL 子查询表达式： "
#. Tag: programlisting
#: basic_mapping.xml:476
@@ -1003,15 +670,8 @@
#. Tag: para
#: basic_mapping.xml:478
#, no-c-format
-msgid ""
-"Declare the tables to synchronize this entity with, ensuring that auto-flush "
-"happens correctly and that queries against the derived entity do not return "
-"stale data. The <literal><subselect></literal> is available both as an "
-"attribute and a nested mapping element."
-msgstr ""
-"定义这个实体用到的表为同步（synchronize），确保自动刷新（auto-flush）正确执"
-"行，并且依赖原实体的查询不会返回过期数据。在属性元素和嵌套映射元素中都可使用 <literal><subselect></"
-"literal>。"
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly and that queries against the derived entity do not return stale data. The <literal><subselect></literal> is available both as an attribute and a nested mapping element."
+msgstr "定义这个实体用到的表为同步（synchronize），确保自动刷新（auto-flush）正确执行，并且依赖原实体的查询不会返回过期数据。在属性元素和嵌套映射元素中都可使用 <literal><subselect></literal>。"
#. Tag: title
#: basic_mapping.xml:488
@@ -1022,16 +682,8 @@
#. Tag: para
#: basic_mapping.xml:490
#, no-c-format
-msgid ""
-"Mapped classes <emphasis>must</emphasis> declare the primary key column of "
-"the database table. Most classes will also have a JavaBeans-style property "
-"holding the unique identifier of an instance. The <literal><id></"
-"literal> element defines the mapping from that property to the primary key "
-"column."
-msgstr ""
-"被映射的类<emphasis>必须</emphasis>定义对应数据库表主键字段。大多数类有一个 "
-"JavaBeans 风格的属性， 为每一个实例包含唯一的标识。<literal><id></"
-"literal> 元素定义了该属性到数据库表主键字段的映射。"
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal><id></literal> element defines the mapping from that property to the primary key column."
+msgstr "被映射的类<emphasis>必须</emphasis>定义对应数据库表主键字段。大多数类有一个 JavaBeans 风格的属性， 为每一个实例包含唯一的标识。<literal><id></literal> 元素定义了该属性到数据库表主键字段的映射。"
#. Tag: programlisting
#: basic_mapping.xml:505
@@ -1066,7 +718,8 @@
msgstr "<literal>name</literal>（可选）：标识属性的名字。 "
#. Tag: para
-#: basic_mapping.xml:513 basic_mapping.xml:1347
+#: basic_mapping.xml:513
+#: basic_mapping.xml:1347
#, no-c-format
msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
msgstr "<literal>type</literal>（可选）：一个 Hibernate 类型的名字。"
@@ -1074,62 +727,38 @@
#. Tag: para
#: basic_mapping.xml:518
#, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of the primary key column."
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the primary key column."
msgstr "<literal>column</literal>（可选 — 默认为属性名）：主键字段的名字。 "
#. Tag: para
#: basic_mapping.xml:524
#, no-c-format
-msgid ""
-"<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" "
-"value): an identifier property value that indicates an instance is newly "
-"instantiated (unsaved), distinguishing it from detached instances that were "
-"saved or loaded in a previous session."
-msgstr ""
-"<literal>unsaved-value</literal>（可选 — 默认为一个切合实际（sensible）的"
-"值）：一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。这可以把这"
-"种实例和从以前的 session 中装载过（可能又做过修改--译者注）但未再次持久化的实"
-"例区分开来。 "
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): an identifier property value that indicates an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr "<literal>unsaved-value</literal>（可选 — 默认为一个切合实际（sensible）的值）：一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。这可以把这种实例和从以前的 session 中装载过（可能又做过修改--译者注）但未再次持久化的实例区分开来。 "
#. Tag: para
#: basic_mapping.xml:532
#, no-c-format
-msgid ""
-"<literal>access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate should use for accessing the property "
-"value."
-msgstr ""
-"<literal>access</literal>（可选 — 默认为 <literal>property</literal>）："
-"Hibernate 用来访问属性值的策略。 "
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate should use for accessing the property value."
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。 "
#. Tag: para
#: basic_mapping.xml:540
#, no-c-format
-msgid ""
-"If the <literal>name</literal> attribute is missing, it is assumed that the "
-"class has no identifier property."
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
msgstr "如果 <literal>name</literal> 属性不存在，会认为这个类没有标识属性。"
#. Tag: para
#: basic_mapping.xml:545
#, no-c-format
-msgid ""
-"The <literal>unsaved-value</literal> attribute is almost never needed in "
-"Hibernate3."
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
msgstr "<literal>unsaved-value</literal> 属性在 Hibernate3 中几乎不再需要。"
#. Tag: para
#: basic_mapping.xml:549
#, no-c-format
-msgid ""
-"There is an alternative <literal><composite-id></literal> declaration "
-"that allows access to legacy data with composite keys. Its use is strongly "
-"discouraged for anything else."
-msgstr ""
-"还有一个另外的 <literal><composite-id></literal> 定义可以访问旧式的多主"
-"键数据。我们非常不鼓励使用这种方式。"
+msgid "There is an alternative <literal><composite-id></literal> declaration that allows access to legacy data with composite keys. Its use is strongly discouraged for anything else."
+msgstr "还有一个另外的 <literal><composite-id></literal> 定义可以访问旧式的多主键数据。我们非常不鼓励使用这种方式。"
#. Tag: title
#: basic_mapping.xml:555
@@ -1140,16 +769,8 @@
#. Tag: para
#: basic_mapping.xml:557
#, no-c-format
-msgid ""
-"The optional <literal><generator></literal> child element names a Java "
-"class used to generate unique identifiers for instances of the persistent "
-"class. If any parameters are required to configure or initialize the "
-"generator instance, they are passed using the <literal><param></"
-"literal> element."
-msgstr ""
-"可选的 <literal><generator></literal> 子元素是一个 Java 类的名字，用来"
-"为该持久化类的实例生成唯一的标识。如果这个生成器实例需要某些配置值或者初始化"
-"参数，用 <literal><param></literal> 元素来传递。"
+msgid "The optional <literal><generator></literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal><param></literal> element."
+msgstr "可选的 <literal><generator></literal> 子元素是一个 Java 类的名字，用来为该持久化类的实例生成唯一的标识。如果这个生成器实例需要某些配置值或者初始化参数，用 <literal><param></literal> 元素来传递。"
#. Tag: programlisting
#: basic_mapping.xml:564
@@ -1172,16 +793,8 @@
#. Tag: para
#: basic_mapping.xml:566
#, no-c-format
-msgid ""
-"All generators implement the interface <literal>org.hibernate.id."
-"IdentifierGenerator</literal>. This is a very simple interface. Some "
-"applications can choose to provide their own specialized implementations, "
-"however, Hibernate provides a range of built-in implementations. The "
-"shortcut names for the built-in generators are as follows:"
-msgstr ""
-"所有的生成器都实现 <literal>org.hibernate.id.IdentifierGenerator</literal> 接"
-"口。这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当"
-"然，Hibernate 提供了很多内置的实现。下面是一些内置生成器的快捷名字： "
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface. Some applications can choose to provide their own specialized implementations, however, Hibernate provides a range of built-in implementations. The shortcut names for the built-in generators are as follows:"
+msgstr "所有的生成器都实现 <literal>org.hibernate.id.IdentifierGenerator</literal> 接口。这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当然，Hibernate 提供了很多内置的实现。下面是一些内置生成器的快捷名字： "
#. Tag: literal
#: basic_mapping.xml:574
@@ -1192,15 +805,8 @@
#. Tag: para
#: basic_mapping.xml:576
#, no-c-format
-msgid ""
-"generates identifiers of type <literal>long</literal>, <literal>short</"
-"literal> or <literal>int</literal> that are unique only when no other "
-"process is inserting data into the same table. <emphasis>Do not use in a "
-"cluster.</emphasis>"
-msgstr ""
-"用于为 <literal>long</literal>, <literal>short</literal> 或者 <literal>int</"
-"literal> 类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使"
-"用。<emphasis>在集群下不要使用。</emphasis>"
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr "用于为 <literal>long</literal>, <literal>short</literal> 或者 <literal>int</literal> 类型生成 唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。<emphasis>在集群下不要使用。</emphasis>"
#. Tag: literal
#: basic_mapping.xml:585
@@ -1211,14 +817,8 @@
#. Tag: para
#: basic_mapping.xml:587
#, no-c-format
-msgid ""
-"supports identity columns in DB2, MySQL, MS SQL Server, Sybase and "
-"HypersonicSQL. The returned identifier is of type <literal>long</literal>, "
-"<literal>short</literal> or <literal>int</literal>."
-msgstr ""
-"对 DB2，MySQL，MS SQL Server，Sybase 和 HypersonicSQL 的内置标识字段提供支"
-"持。返回的标识符是 <literal>long</literal>，<literal>short</literal> 或者 "
-"<literal>int</literal> 类型的。"
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr "对 DB2，MySQL，MS SQL Server，Sybase 和 HypersonicSQL 的内置标识字段提供支持。返回的标识符是 <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> 类型的。"
#. Tag: literal
#: basic_mapping.xml:595
@@ -1229,14 +829,8 @@
#. Tag: para
#: basic_mapping.xml:597
#, no-c-format
-msgid ""
-"uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in "
-"Interbase. The returned identifier is of type <literal>long</literal>, "
-"<literal>short</literal> or <literal>int</literal>"
-msgstr ""
-"在 DB2，PostgreSQL，Oracle，SAP DB，McKoi 中使用序列（sequence）， 而在 "
-"Interbase 中使用生成器（generator）。返回的标识符是 <literal>long</literal>，"
-"<literal>short</literal> 或者 <literal>int</literal> 类型的。"
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr "在 DB2，PostgreSQL，Oracle，SAP DB，McKoi 中使用序列（sequence）， 而在 Interbase 中使用生成器（generator）。返回的标识符是 <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> 类型的。"
#. Tag: literal
#: basic_mapping.xml:605
@@ -1247,18 +841,8 @@
#. Tag: para
#: basic_mapping.xml:607
#, no-c-format
-msgid ""
-"uses a hi/lo algorithm to efficiently generate identifiers of type "
-"<literal>long</literal>, <literal>short</literal> or <literal>int</literal>, "
-"given a table and column (by default <literal>hibernate_unique_key</literal> "
-"and <literal>next_hi</literal> respectively) as a source of hi values. The "
-"hi/lo algorithm generates identifiers that are unique only for a particular "
-"database."
-msgstr ""
-"使用一个高/低位算法高效的生成 <literal>long</literal>，<literal>short</"
-"literal> 或者 <literal>int</literal> 类型的标识符。给定一个表和字段（默认分别"
-"是 <literal>hibernate_unique_key</literal> 和 <literal>next_hi</literal>）作"
-"为高位值的来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。"
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr "使用一个高/低位算法高效的生成 <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> 类型的标识符。给定一个表和字段（默认分别是 <literal>hibernate_unique_key</literal> 和 <literal>next_hi</literal>）作为高位值的来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。"
#. Tag: literal
#: basic_mapping.xml:617
@@ -1269,14 +853,8 @@
#. Tag: para
#: basic_mapping.xml:619
#, no-c-format
-msgid ""
-"uses a hi/lo algorithm to efficiently generate identifiers of type "
-"<literal>long</literal>, <literal>short</literal> or <literal>int</literal>, "
-"given a named database sequence."
-msgstr ""
-"使用一个高/低位算法来高效的生成 <literal>long</literal>，<literal>short</"
-"literal> 或者 <literal>int</literal> 类型的标识符，给定一个数据库序列"
-"（sequence)的名字。"
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr "使用一个高/低位算法来高效的生成 <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> 类型的标识符，给定一个数据库序列（sequence)的名字。"
#. Tag: literal
#: basic_mapping.xml:627
@@ -1287,13 +865,8 @@
#. Tag: para
#: basic_mapping.xml:629
#, no-c-format
-msgid ""
-"uses a 128-bit UUID algorithm to generate identifiers of type string that "
-"are unique within a network (the IP address is used). The UUID is encoded as "
-"a string of 32 hexadecimal digits in length."
-msgstr ""
-"用一个 128-bit 的 UUID 算法生成字符串类型的标识符，这在一个网络中是唯一的（使"
-"用了 IP 地址）。UUID 被编码为一个 32 位 16 进制数字的字符串。 "
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string that are unique within a network (the IP address is used). The UUID is encoded as a string of 32 hexadecimal digits in length."
+msgstr "用一个 128-bit 的 UUID 算法生成字符串类型的标识符，这在一个网络中是唯一的（使用了 IP 地址）。UUID 被编码为一个 32 位 16 进制数字的字符串。 "
#. Tag: literal
#: basic_mapping.xml:637
@@ -1316,13 +889,8 @@
#. Tag: para
#: basic_mapping.xml:647
#, no-c-format
-msgid ""
-"selects <literal>identity</literal>, <literal>sequence</literal> or "
-"<literal>hilo</literal> depending upon the capabilities of the underlying "
-"database."
-msgstr ""
-"根据底层数据库的能力选择 <literal>identity</literal>、<literal>sequence</"
-"literal> 或者 <literal>hilo</literal> 中的一个。"
+msgid "selects <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr "根据底层数据库的能力选择 <literal>identity</literal>、<literal>sequence</literal> 或者 <literal>hilo</literal> 中的一个。"
#. Tag: literal
#: basic_mapping.xml:655
@@ -1333,13 +901,8 @@
#. Tag: para
#: basic_mapping.xml:657
#, no-c-format
-msgid ""
-"lets the application assign an identifier to the object before <literal>save"
-"()</literal> is called. This is the default strategy if no <literal><"
-"generator></literal> element is specified."
-msgstr ""
-"让应用程序在调用 <literal>save()</literal> 之前为对象分配一个标识符。这是 "
-"<literal><generator></literal> 元素没有指定时的默认生成策略。"
+msgid "lets the application assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal><generator></literal> element is specified."
+msgstr "让应用程序在调用 <literal>save()</literal> 之前为对象分配一个标识符。这是 <literal><generator></literal> 元素没有指定时的默认生成策略。"
#. Tag: literal
#: basic_mapping.xml:665
@@ -1350,9 +913,7 @@
#. Tag: para
#: basic_mapping.xml:667
#, no-c-format
-msgid ""
-"retrieves a primary key, assigned by a database trigger, by selecting the "
-"row by some unique key and retrieving the primary key value."
+msgid "retrieves a primary key, assigned by a database trigger, by selecting the row by some unique key and retrieving the primary key value."
msgstr "通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。 "
#. Tag: literal
@@ -1364,13 +925,8 @@
#. Tag: para
#: basic_mapping.xml:676
#, no-c-format
-msgid ""
-"uses the identifier of another associated object. It is usually used in "
-"conjunction with a <literal><one-to-one></literal> primary key "
-"association."
-msgstr ""
-"使用另外一个相关联的对象的标识符。它通常和 <literal><one-to-one></"
-"literal> 联合起来使用。"
+msgid "uses the identifier of another associated object. It is usually used in conjunction with a <literal><one-to-one></literal> primary key association."
+msgstr "使用另外一个相关联的对象的标识符。它通常和 <literal><one-to-one></literal> 联合起来使用。"
#. Tag: literal
#: basic_mapping.xml:683
@@ -1381,18 +937,8 @@
#. Tag: para
#: basic_mapping.xml:685
#, no-c-format
-msgid ""
-"a specialized sequence generation strategy that utilizes a database sequence "
-"for the actual value generation, but combines this with JDBC3 "
-"getGeneratedKeys to return the generated identifier value as part of the "
-"insert statement execution. This strategy is only supported on Oracle 10g "
-"drivers targeted for JDK 1.4. Comments on these insert statements are "
-"disabled due to a bug in the Oracle drivers."
-msgstr ""
-"一种特别的序列生成策略，它使用数据库序列来生成实际值，但将它和 JDBC3 的 "
-"getGeneratedKeys 结合在一起，使得在插入语句执行的时候就返回生成的值。目前为止"
-"只有面向 JDK 1.4 的 Oracle 10g 驱动支持这一策略。由于 Oracle 驱动程序的"
-"一个 bug，这些插入语句的注释被关闭了。"
+msgid "a specialized sequence generation strategy that utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to return the generated identifier value as part of the insert statement execution. This strategy is only supported on Oracle 10g drivers targeted for JDK 1.4. Comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr "一种特别的序列生成策略，它使用数据库序列来生成实际值，但将它和 JDBC3 的 getGeneratedKeys 结合在一起，使得在插入语句执行的时候就返回生成的值。目前为止只有面向 JDK 1.4 的 Oracle 10g 驱动支持这一策略。由于 Oracle 驱动程序的一个 bug，这些插入语句的注释被关闭了。"
#. Tag: title
#: basic_mapping.xml:700
@@ -1403,17 +949,8 @@
#. Tag: para
#: basic_mapping.xml:701
#, no-c-format
-msgid ""
-"The <literal>hilo</literal> and <literal>seqhilo</literal> generators "
-"provide two alternate implementations of the hi/lo algorithm. The first "
-"implementation requires a \"special\" database table to hold the next "
-"available \"hi\" value. Where supported, the second uses an Oracle-style "
-"sequence."
-msgstr ""
-"<literal>hilo</literal> 和 <literal>seqhilo</literal> 生成器给出了两种 hi/lo "
-"算法的实现， 这是一种很令人满意的标识符生成算法。第一种实现需要一个“特殊”的数"
-"据库表来保存下一个可用的“hi”值。 第二种实现使用一个 Oracle 风格的序列（在被支"
-"持的情况下）。 "
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. Where supported, the second uses an Oracle-style sequence."
+msgstr "<literal>hilo</literal> 和 <literal>seqhilo</literal> 生成器给出了两种 hi/lo 算法的实现， 这是一种很令人满意的标识符生成算法。第一种实现需要一个“特殊”的数据库表来保存下一个可用的“hi”值。 第二种实现使用一个 Oracle 风格的序列（在被支持的情况下）。 "
#. Tag: programlisting
#: basic_mapping.xml:708
@@ -1456,17 +993,8 @@
#. Tag: para
#: basic_mapping.xml:712
#, no-c-format
-msgid ""
-"Unfortunately, you cannot use <literal>hilo</literal> when supplying your "
-"own <literal>Connection</literal> to Hibernate. When Hibernate uses an "
-"application server datasource to obtain connections enlisted with JTA, you "
-"must configure the <literal>hibernate.transaction.manager_lookup_class</"
-"literal>."
-msgstr ""
-"可惜的是，你在为 Hibernate 自行提供 <literal>Connection</literal> 时无法使用 "
-"<literal>hilo</literal>。 当 Hibernate 使用 JTA 获取应用服务器的数据源连接"
-"时，你必须正确地配置 <literal>hibernate.transaction.manager_lookup_class</"
-"literal>。"
+msgid "Unfortunately, you cannot use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate uses an application server datasource to obtain connections enlisted with JTA, you must configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "可惜的是，你在为 Hibernate 自行提供 <literal>Connection</literal> 时无法使用 <literal>hilo</literal>。 当 Hibernate 使用 JTA 获取应用服务器的数据源连接时，你必须正确地配置 <literal>hibernate.transaction.manager_lookup_class</literal>。"
#. Tag: title
#: basic_mapping.xml:721
@@ -1477,15 +1005,8 @@
#. Tag: para
#: basic_mapping.xml:722
#, no-c-format
-msgid ""
-"The UUID contains: IP address, startup time of the JVM that is accurate to a "
-"quarter second, system time and a counter value that is unique within the "
-"JVM. It is not possible to obtain a MAC address or memory address from Java "
-"code, so this is the best option without using JNI."
-msgstr ""
-"UUID 包含：IP 地址、JVM 的启动时间（精确到 1/4 秒）、系统时间和一个计数器值"
-"（在 JVM 中唯一）。 在 Java 代码中不可能获得 MAC 地址或者内存地址，所以这已经"
-"是我们在不使用 JNI 的前提下的能做的最好实现了。"
+msgid "The UUID contains: IP address, startup time of the JVM that is accurate to a quarter second, system time and a counter value that is unique within the JVM. It is not possible to obtain a MAC address or memory address from Java code, so this is the best option without using JNI."
+msgstr "UUID 包含：IP 地址、JVM 的启动时间（精确到 1/4 秒）、系统时间和一个计数器值（在 JVM 中唯一）。 在 Java 代码中不可能获得 MAC 地址或者内存地址，所以这已经是我们在不使用 JNI 的前提下的能做的最好实现了。"
#. Tag: title
#: basic_mapping.xml:731
@@ -1496,18 +1017,8 @@
#. Tag: para
#: basic_mapping.xml:732
#, no-c-format
-msgid ""
-"For databases that support identity columns (DB2, MySQL, Sybase, MS SQL), "
-"you can use <literal>identity</literal> key generation. For databases that "
-"support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you "
-"can use <literal>sequence</literal> style key generation. Both of these "
-"strategies require two SQL queries to insert a new object. For example:"
-msgstr ""
-"对于内部支持标识字段的数据库（DB2、MySQL、Sybase 和 MS SQL），你可以使用 "
-"<literal>identity</literal> 关键字生成。对于内部支持序列的数据库（DB2、"
-"Oracle、PostgreSQL、Interbase、McKoi 和 SAP DB），你可以使用 "
-"<literal>sequence</literal> 风格的关键字生成。这两种方式对于插入一个新的对象"
-"都需要两次 SQL 查询。例如："
+msgid "For databases that support identity columns (DB2, MySQL, Sybase, MS SQL), you can use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you can use <literal>sequence</literal> style key generation. Both of these strategies require two SQL queries to insert a new object. For example:"
+msgstr "对于内部支持标识字段的数据库（DB2、MySQL、Sybase 和 MS SQL），你可以使用 <literal>identity</literal> 关键字生成。对于内部支持序列的数据库（DB2、Oracle、PostgreSQL、Interbase、McKoi 和 SAP DB），你可以使用 <literal>sequence</literal> 风格的关键字生成。这两种方式对于插入一个新的对象都需要两次 SQL 查询。例如："
#. Tag: programlisting
#: basic_mapping.xml:740
@@ -1529,28 +1040,19 @@
#: basic_mapping.xml:742
#, no-c-format
msgid ""
-"<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0"
-"\">\n"
+"<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
" <generator class=\"identity\"/>\n"
"</id>]]>"
msgstr ""
-"<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0"
-"\">\n"
+"<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value=\"0\">\n"
" <generator class=\"identity\"/>\n"
"</id>]]>"
#. Tag: para
#: basic_mapping.xml:744
#, no-c-format
-msgid ""
-"For cross-platform development, the <literal>native</literal> strategy will, "
-"depending on the capabilities of the underlying database, choose from the "
-"<literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</"
-"literal> strategies."
-msgstr ""
-"对于跨平台开发，<literal>native</literal> 策略会从 <literal>identity</"
-"literal>、<literal>sequence</literal> 和 <literal>hilo</literal> 中进行选择，"
-"选择哪一个，这取决于底层数据库的支持能力。"
+msgid "For cross-platform development, the <literal>native</literal> strategy will, depending on the capabilities of the underlying database, choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies."
+msgstr "对于跨平台开发，<literal>native</literal> 策略会从 <literal>identity</literal>、<literal>sequence</literal> 和 <literal>hilo</literal> 中进行选择，选择哪一个，这取决于底层数据库的支持能力。"
#. Tag: title
#: basic_mapping.xml:752
@@ -1561,36 +1063,14 @@
#. Tag: para
#: basic_mapping.xml:753
#, no-c-format
-msgid ""
-"If you want the application to assign identifiers, as opposed to having "
-"Hibernate generate them, you can use the <literal>assigned</literal> "
-"generator. This special generator uses the identifier value already assigned "
-"to the object's identifier property. The generator is used when the primary "
-"key is a natural key instead of a surrogate key. This is the default "
-"behavior if you do not specify a <literal><generator></literal> "
-"element."
-msgstr ""
-"如果你需要应用程序分配一个标示符（而非 Hibernate 来生成），你可以使用 "
-"<literal>assigned</literal> 生成器。这种特殊的生成器会使用已经分配给对象的标"
-"识符属性的标识符值。 这个生成器使用一个自然键（natural key，有商业意义的列－"
-"译注）作为主键，而不是使用一个代理键（ surrogate key，没有商业意义的列－译"
-"注）。这是没有指定 <literal><generator></literal> 元素时的默认行为。"
+msgid "If you want the application to assign identifiers, as opposed to having Hibernate generate them, you can use the <literal>assigned</literal> generator. This special generator uses the identifier value already assigned to the object's identifier property. The generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do not specify a <literal><generator></literal> element."
+msgstr "如果你需要应用程序分配一个标示符（而非 Hibernate 来生成），你可以使用 <literal>assigned</literal> 生成器。这种特殊的生成器会使用已经分配给对象的标识符属性的标识符值。 这个生成器使用一个自然键（natural key，有商业意义的列－译注）作为主键，而不是使用一个代理键（ surrogate key，没有商业意义的列－译注）。这是没有指定 <literal><generator></literal> 元素时的默认行为。"
#. Tag: para
#: basic_mapping.xml:762
#, no-c-format
-msgid ""
-"The <literal>assigned</literal> generator makes Hibernate use "
-"<literal>unsaved-value=\"undefined\"</literal>. This forces Hibernate to go "
-"to the database to determine if an instance is transient or detached, unless "
-"there is a version or timestamp property, or you define <literal>Interceptor."
-"isUnsaved()</literal>."
-msgstr ""
-"当选择 <literal>assigned</literal> 生成器时，除非有一个 version 或 timestamp "
-"属性，或者你定义了 <literal>Interceptor.isUnsaved()</literal>，否则需要让 "
-"Hiberante 使用 <literal>unsaved-value=\"undefined\"</literal>，强制 "
-"Hibernatet 查询数据库来确定一个实例是瞬时的（transient） 还是脱管的"
-"（detached）。"
+msgid "The <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>. This forces Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr "当选择 <literal>assigned</literal> 生成器时，除非有一个 version 或 timestamp 属性，或者你定义了 <literal>Interceptor.isUnsaved()</literal>，否则需要让 Hiberante 使用 <literal>unsaved-value=\"undefined\"</literal>，强制 Hibernatet 查询数据库来确定一个实例是瞬时的（transient） 还是脱管的（detached）。"
#. Tag: title
#: basic_mapping.xml:772
@@ -1623,15 +1103,8 @@
#. Tag: para
#: basic_mapping.xml:779
#, no-c-format
-msgid ""
-"In the above example, there is a unique valued property named "
-"<literal>socialSecurityNumber</literal>. It is defined by the class, as a "
-"natural key and a surrogate key named <literal>person_id</literal>, whose "
-"value is generated by a trigger."
-msgstr ""
-"在上面的例子中，类定义了一个命名为 <literal>socialSecurityNumber</literal> 的具有"
-"唯一值的属性，它是一个自然键（natural key），命名为 <literal>person_id</"
-"literal> 的代理键（surrogate key）的值由触发器生成。"
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal>. It is defined by the class, as a natural key and a surrogate key named <literal>person_id</literal>, whose value is generated by a trigger."
+msgstr "在上面的例子中，类定义了一个命名为 <literal>socialSecurityNumber</literal> 的具有唯一值的属性，它是一个自然键（natural key），命名为 <literal>person_id</literal> 的代理键（surrogate key）的值由触发器生成。"
#. Tag: title
#: basic_mapping.xml:791
@@ -1642,192 +1115,103 @@
#. Tag: para
#: basic_mapping.xml:793
#, no-c-format
-msgid ""
-"Starting with release 3.2.3, there are 2 new generators which represent a re-"
-"thinking of 2 different aspects of identifier generation. The first aspect "
-"is database portability; the second is optimization Optimization means that "
-"you do not have to query the database for every request for a new identifier "
-"value. These two new generators are intended to take the place of some of "
-"the named generators described above, starting in 3.3.x. However, they are "
-"included in the current releases and can be referenced by FQN."
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization Optimization means that you do not have to query the database for every request for a new identifier value. These two new generators are intended to take the place of some of the named generators described above, starting in 3.3.x. However, they are included in the current releases and can be referenced by FQN."
msgstr "从 3.2.3 版本开始，有两个代表不同标识符生成概念的新的生成器。第一个概念是数据库移植性；第二个是优化。优化表示你不需对每个新标识符的请求都查询数据库。从 3.3.x 开始，这两个新的生成器都是用来取代上面所述的生成器的。然而，它们也包括在当前版本里且可以由 FQN 进行引用。"
#. Tag: para
#: basic_mapping.xml:801
#, no-c-format
-msgid ""
-"The first of these new generators is <literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal> which is intended, firstly, as a "
-"replacement for the <literal>sequence</literal> generator and, secondly, as "
-"a better portability generator than <literal>native</literal>. This is "
-"because <literal>native</literal> generally chooses between "
-"<literal>identity</literal> and <literal>sequence</literal> which have "
-"largely different semantics that can cause subtle issues in applications "
-"eyeing portability. <literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal>, however, achieves portability in a "
-"different manner. It chooses between a table or a sequence in the database "
-"to store its incrementing values, depending on the capabilities of the "
-"dialect being used. The difference between this and <literal>native</"
-"literal> is that table-based and sequence-based storage have the same exact "
-"semantic. In fact, sequences are exactly what Hibernate tries to emulate "
-"with its table-based generators. This generator has a number of "
-"configuration parameters:"
-msgstr ""
-"这些生成器的第一个是 <literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal>，首先，它是作为 <literal>sequence</literal> 生成器的替代物，其次，它是比 <literal>native</literal> 具有更好移植性的生成器。这是因为 <literal>native</literal> 通常在 <literal>identity</literal> 和 <literal>sequence</literal> 之间选择，它有差别很大的 semantic，在移植时会导致潜在的问题。然而，<literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal> 以不同的方式实现移植性。它根据所使用的方言的能力，在数据库表或序列之间选择以存储其增量。这和 <literal>native</"
-"literal> 的区别是基于表或序列的存储具有恰好相同的 semantic。实际上，序列就是 Hibernate 试图用基于表的生成器来模拟的。这个生成器有如下的配置参数："
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended, firstly, as a replacement for the <literal>sequence</literal> generator and, secondly, as a better portability generator than <literal>native</literal>. This is because <literal>native</literal> generally chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics that can cause subtle issues in applications eyeing portability. <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal>, however, achieves portability in a different manner. It chooses between a table or a sequence in the database to store its incrementing values, depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic. In fact, sequences are exactly what Hibernate tries to emulate with!
its table-based generators. This generator has a number of configuration parameters:"
+msgstr "这些生成器的第一个是 <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal>，首先，它是作为 <literal>sequence</literal> 生成器的替代物，其次，它是比 <literal>native</literal> 具有更好移植性的生成器。这是因为 <literal>native</literal> 通常在 <literal>identity</literal> 和 <literal>sequence</literal> 之间选择，它有差别很大的 semantic，在移植时会导致潜在的问题。然而，<literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> 以不同的方式实现移植性。它根据所使用的方言的能力，在数据库表或序列之间选择以存储其增量。这和 <literal>native</literal> 的区别是基于表或序列的存储具有恰好相同的 semantic。实际上，序列就是 Hibernate 试图用基于表的生成器来模拟的。这个生成器有如下的配置参数："
#. Tag: para
#: basic_mapping.xml:815
#, no-c-format
-msgid ""
-"<literal>sequence_name</literal> (optional, defaults to "
-"<literal>hibernate_sequence</literal>): the name of the sequence or table to "
-"be used."
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): the name of the sequence or table to be used."
msgstr "<literal>sequence_name</literal>（可选 — 默认为 <literal>hibernate_sequence</literal>）：序列或表的名字"
#. Tag: para
#: basic_mapping.xml:821
#, no-c-format
-msgid ""
-"<literal>initial_value</literal> (optional, defaults to <literal>1</"
-"literal>): the initial value to be retrieved from the sequence/table. In "
-"sequence creation terms, this is analogous to the clause typically named "
-"\"STARTS WITH\"."
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): the initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typically named \"STARTS WITH\"."
msgstr "<literal>initial_value</literal>（可选，默认为 <literal>1</literal>）：从序列/表里获取的初始值。按照序列创建的术语，这等同于子句 \"STARTS WITH\"。"
#. Tag: para
#: basic_mapping.xml:828
#, no-c-format
-msgid ""
-"<literal>increment_size</literal> (optional - defaults to <literal>1</"
-"literal>): the value by which subsequent calls to the sequence/table should "
-"differ. In sequence creation terms, this is analogous to the clause "
-"typically named \"INCREMENT BY\"."
-msgstr ""
-"<literal>increment_size</literal>（可选 - 缺省为 <literal>1</"
-"literal>）：对序列/表的调用应该区分的值。按照序列创建的术语，这等同于子句 \"INCREMENT BY\"。"
+msgid "<literal>increment_size</literal> (optional - defaults to <literal>1</literal>): the value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typically named \"INCREMENT BY\"."
+msgstr "<literal>increment_size</literal>（可选 - 缺省为 <literal>1</literal>）：对序列/表的调用应该区分的值。按照序列创建的术语，这等同于子句 \"INCREMENT BY\"。"
#. Tag: para
#: basic_mapping.xml:835
#, no-c-format
-msgid ""
-"<literal>force_table_use</literal> (optional - defaults to <literal>false</"
-"literal>): should we force the use of a table as the backing structure even "
-"though the dialect might support sequence?"
-msgstr ""
-"<literal>force_table_use</literal>（可选 - 缺省为 <literal>false</"
-"literal>）：即使方言可能支持序列，是否也应该强制把表用作后台结构。"
+msgid "<literal>force_table_use</literal> (optional - defaults to <literal>false</literal>): should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr "<literal>force_table_use</literal>（可选 - 缺省为 <literal>false</literal>）：即使方言可能支持序列，是否也应该强制把表用作后台结构。"
#. Tag: para
#: basic_mapping.xml:842
#, no-c-format
-msgid ""
-"<literal>value_column</literal> (optional - defaults to <literal>next_val</"
-"literal>): only relevant for table structures, it is the name of the column "
-"on the table which is used to hold the value."
-msgstr ""
-"<literal>value_column</literal>（可选 - 缺省为 <literal>next_val</"
-"literal>）：只和表结构相关，它是用于保存值的字段的名称。"
+msgid "<literal>value_column</literal> (optional - defaults to <literal>next_val</literal>): only relevant for table structures, it is the name of the column on the table which is used to hold the value."
+msgstr "<literal>value_column</literal>（可选 - 缺省为 <literal>next_val</literal>）：只和表结构相关，它是用于保存值的字段的名称。"
#. Tag: para
#: basic_mapping.xml:849
#, no-c-format
-msgid ""
-"<literal>optimizer</literal> (optional - defaults to <literal>none</"
-"literal>): See"
+msgid "<literal>optimizer</literal> (optional - defaults to <literal>none</literal>): See"
msgstr "<literal>optimizer</literal>（可选 — 默认是<literal>none</literal>）："
#. Tag: para
#: basic_mapping.xml:855
#, no-c-format
-msgid ""
-"The second of these new generators is <literal>org.hibernate.id.enhanced."
-"TableGenerator</literal>, which is intended, firstly, as a replacement for "
-"the <literal>table</literal> generator, even though it actually functions "
-"much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</"
-"literal>, and secondly, as a re-implementation of <literal>org.hibernate.id."
-"MultipleHiLoPerTableGenerator</literal> that utilizes the notion of "
-"pluggable optimizers. Essentially this generator defines a table capable of "
-"holding a number of different increment values simultaneously by using "
-"multiple distinctly keyed rows. This generator has a number of configuration "
-"parameters:"
-msgstr ""
-"新生成器的第二个是 <literal>org.hibernate.id.enhanced."
-"TableGenerator</literal>，它的目的首先是替代 <literal>table</literal> 生成器，即使它实际上比 <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</"
-"literal> 功能要强得多；其次，作为利用可插拔 optimizer 的 <literal>org.hibernate.id."
-"MultipleHiLoPerTableGenerator</literal> 的替代品。基本上这个生成器定义了一个可以利用多个不同的键值记录存储大量不同增量值的表。这个生成器有如下的配置参数："
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal>, which is intended, firstly, as a replacement for the <literal>table</literal> generator, even though it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>, and secondly, as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> that utilizes the notion of pluggable optimizers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr "新生成器的第二个是 <literal>org.hibernate.id.enhanced.TableGenerator</literal>，它的目的首先是替代 <literal>table</literal> 生成器，即使它实际上比 <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> 功能要强得多；其次，作为利用可插拔 optimizer 的 <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> 的替代品。基本上这个生成器定义了一个可以利用多个不同的键值记录存储大量不同增量值的表。这个生成器有如下的配置参数："
#. Tag: para
#: basic_mapping.xml:865
#, no-c-format
-msgid ""
-"<literal>table_name</literal> (optional - defaults to "
-"<literal>hibernate_sequences</literal>): the name of the table to be used."
+msgid "<literal>table_name</literal> (optional - defaults to <literal>hibernate_sequences</literal>): the name of the table to be used."
msgstr "<literal>table_name</literal>（可选 — 默认是 <literal>hibernate_sequences</literal>）：所用的表的名称。"
#. Tag: para
#: basic_mapping.xml:871
#, no-c-format
-msgid ""
-"<literal>value_column_name</literal> (optional - defaults to "
-"<literal>next_val</literal>): the name of the column on the table that is "
-"used to hold the value."
-msgstr ""
-"<literal>value_column_name</literal>（可选 — 默认为 <literal>next_val</literal>）：用于存储这些值的表的字段的名"
-"字。"
+msgid "<literal>value_column_name</literal> (optional - defaults to <literal>next_val</literal>): the name of the column on the table that is used to hold the value."
+msgstr "<literal>value_column_name</literal>（可选 — 默认为 <literal>next_val</literal>）：用于存储这些值的表的字段的名字。"
#. Tag: para
#: basic_mapping.xml:877
#, no-c-format
-msgid ""
-"<literal>segment_column_name</literal> (optional - defaults to "
-"<literal>sequence_name</literal>): the name of the column on the table that "
-"is used to hold the \"segment key\". This is the value which identifies "
-"which increment value to use."
+msgid "<literal>segment_column_name</literal> (optional - defaults to <literal>sequence_name</literal>): the name of the column on the table that is used to hold the \"segment key\". This is the value which identifies which increment value to use."
msgstr "<literal>segment_column_name</literal>（可选，默认为 <literal>sequence_name</literal>）：用于保存 \"segment key\" 的字段的名称。这是标识使用哪个增量值的值。"
#. Tag: para
#: basic_mapping.xml:884
#, no-c-format
-msgid ""
-"<literal>segment_value</literal> (optional - defaults to <literal>default</"
-"literal>): The \"segment key\" value for the segment from which we want to "
-"pull increment values for this generator."
+msgid "<literal>segment_value</literal> (optional - defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
msgstr "<literal>segment_value</literal>（可选，默认为 <literal>default</literal>）：我们为这个生成器获取增量值的 segment 的 \"segment key\"。"
#. Tag: para
#: basic_mapping.xml:891
#, no-c-format
-msgid ""
-"<literal>segment_value_length</literal> (optional - defaults to "
-"<literal>255</literal>): Used for schema generation; the column size to "
-"create this segment key column."
+msgid "<literal>segment_value_length</literal> (optional - defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
msgstr "<literal>segment_value_length</literal>（可选 — 默认为 <literal>255</literal>）：用于 schema 生成；创建 Segment Key 字段的字段大小。"
#. Tag: para
#: basic_mapping.xml:897
#, no-c-format
-msgid ""
-"<literal>initial_value</literal> (optional - defaults to <literal>1</"
-"literal>): The initial value to be retrieved from the table."
+msgid "<literal>initial_value</literal> (optional - defaults to <literal>1</literal>): The initial value to be retrieved from the table."
msgstr "<literal>initial_value</literal>（可选 — 默认是 <literal>1</literal>）：从表里获取的初始值。"
#. Tag: para
#: basic_mapping.xml:903
#, no-c-format
-msgid ""
-"<literal>increment_size</literal> (optional - defaults to <literal>1</"
-"literal>): The value by which subsequent calls to the table should differ."
+msgid "<literal>increment_size</literal> (optional - defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
msgstr "<literal>increment_size</literal>（可选 — 默认是 <literal>1</literal>）：对表随后的调用应该区分的值。"
#. Tag: para
#: basic_mapping.xml:909
#, no-c-format
-msgid ""
-"<literal>optimizer</literal> (optional - defaults to <literal></literal>): "
-"See"
+msgid "<literal>optimizer</literal> (optional - defaults to <literal></literal>): See"
msgstr "<literal>optimizer</literal>（可选 — 默认是 <literal> </literal>）："
#. Tag: title
@@ -1839,47 +1223,25 @@
#. Tag: para
#: basic_mapping.xml:919
#, no-c-format
-msgid ""
-"For identifier generators that store values in the database, it is "
-"inefficient for them to hit the database on each and every call to generate "
-"a new identifier value. Instead, you can group a bunch of them in memory and "
-"only hit the database when you have exhausted your in-memory value group. "
-"This is the role of the pluggable optimizers. Currently only the two "
-"enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> "
-"support this operation."
+msgid "For identifier generators that store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you can group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\"/> support this operation."
msgstr "对于在数据库里存储值的标识符生成器，生成新标识符时的每次调用都访问数据库是低效的。因此，你可以把它们在内存里分组并只有在快用光内存时才访问数据库。这是可插拔 optimizer 的任务。目前只有两个增强型的生成器支持这个操作（<xref linkend=\"mapping-declaration-id-enhanced\"/>）。"
#. Tag: para
#: basic_mapping.xml:927
#, no-c-format
-msgid ""
-"<literal>none</literal> (generally this is the default if no optimizer was "
-"specified): this will not perform any optimizations and hit the database for "
-"each and every request."
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): this will not perform any optimizations and hit the database for each and every request."
msgstr "<literal>none</literal>（如果没有指定 optimizer，通常这是缺省配置）：这不会执行任何优化，在每次请求时都访问数据库。"
#. Tag: para
#: basic_mapping.xml:933
#, no-c-format
-msgid ""
-"<literal>hilo</literal>: applies a hi/lo algorithm around the database "
-"retrieved values. The values from the database for this optimizer are "
-"expected to be sequential. The values retrieved from the database structure "
-"for this optimizer indicates the \"group number\". The "
-"<literal>increment_size</literal> is multiplied by that value in memory to "
-"define a group \"hi value\"."
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\". The <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
msgstr "<literal>hilo</literal>：对从数据库获取的值应用 hi/lo 算法。用于这个 optimizer 的从数据库获取的值应该是有序的。它们表明“组编号”。<literal>increment_size</literal> 将乘以内存里的值来定义组的“hi 值”。"
#. Tag: para
#: basic_mapping.xml:942
#, no-c-format
-msgid ""
-"<literal>pooled</literal>: as with the case of <literal>hilo</literal>, this "
-"optimizer attempts to minimize the number of hits to the database. Here, "
-"however, we simply store the starting value for the \"next group\" into the "
-"database structure rather than a sequential value in combination with an in-"
-"memory grouping algorithm. Here, <literal>increment_size</literal> refers to "
-"the values coming from the database."
+msgid "<literal>pooled</literal>: as with the case of <literal>hilo</literal>, this optimizer attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. Here, <literal>increment_size</literal> refers to the values coming from the database."
msgstr "<literal>pooled</literal>：和 <literal>hilo</literal> 一样，这个 optimizer 试图最小化对数据库的访问。然而，我们只是简单地把“下一组”的起始值而不是把序列值和分组算法的组合存入到数据库结构里。在这里，<literal>increment_size</literal> 表示数据库里的值。"
#. Tag: title
@@ -1899,10 +1261,8 @@
" access=\"field|property|ClassName\">\n"
" node=\"element-name|.\"\n"
"\n"
-" <key-property name=\"propertyName\" type=\"typename\" column="
-"\"column_name\"/>\n"
-" <key-many-to-one name=\"propertyName class=\"ClassName\" column="
-"\"column_name\"/>\n"
+" <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+" <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
" ......\n"
"</composite-id>]]>"
msgstr ""
@@ -1913,82 +1273,48 @@
" access=\"field|property|ClassName\">\n"
" node=\"element-name|.\"\n"
"\n"
-" <key-property name=\"propertyName\" type=\"typename\" column="
-"\"column_name\"/>\n"
-" <key-many-to-one name=\"propertyName class=\"ClassName\" column="
-"\"column_name\"/>\n"
+" <key-property name=\"propertyName\" type=\"typename\" column=\"column_name\"/>\n"
+" <key-many-to-one name=\"propertyName class=\"ClassName\" column=\"column_name\"/>\n"
" ......\n"
"</composite-id>]]>"
#. Tag: para
#: basic_mapping.xml:959
-#, fuzzy, no-c-format
-msgid ""
-"A table with a composite key can be mapped with multiple properties of the "
-"class as identifier properties. The <literal><composite-id></literal> "
-"element accepts <literal><key-property></literal> property mappings "
-"and <literal><key-many-to-one></literal> mappings as child elements."
-msgstr ""
-"如果表使用联合主键，你可以映射类的多个属性为标识符属性。<literal><"
-"composite-id></literal> 元素接受 <literal><key-property></literal> "
-"属性映射和 <literal><key-many-to-one></literal> 属性映射作为子元素。"
+#, no-c-format
+msgid "A table with a composite key can be mapped with multiple properties of the class as identifier properties. The <literal><composite-id></literal> element accepts <literal><key-property></literal> property mappings and <literal><key-many-to-one></literal> mappings as child elements."
+msgstr "如果表使用联合主键，你可以映射类的多个属性为标识符属性。<literal><composite-id></literal> 元素接受 <literal><key-property></literal> 属性映射和 <literal><key-many-to-one></literal> 属性映射作为子元素。 "
#. Tag: programlisting
#: basic_mapping.xml:966
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<composite-id>\n"
" <key-property name=\"medicareNumber\"/>\n"
" <key-property name=\"dependent\"/>\n"
"</composite-id>]]>"
msgstr ""
-"<composite-id>\n"
-" <key-property name=\"medicareNumber\"/>\n"
-" <key-property name=\"dependent\"/>\n"
-"</composite-id>"
+"<![CDATA[<composite-id>\n"
+" <key-property name=\"medicareNumber\"/>\n"
+" <key-property name=\"dependent\"/>\n"
+"</composite-id>]]>"
#. Tag: para
#: basic_mapping.xml:968
-#, fuzzy, no-c-format
-msgid ""
-"The persistent class <emphasis>must</emphasis> override <literal>equals()</"
-"literal> and <literal>hashCode()</literal> to implement composite identifier "
-"equality. It must also implement <literal>Serializable</literal>."
-msgstr ""
-"你的持久化类<emphasis>必须</emphasis>重载 <literal>equals()</literal> 和 "
-"<literal>hashCode()</literal> 方法，来实现组合的标识符的相等判断。实现 "
-"<literal>Serializable</literal> 接口也是必须的。"
+#, no-c-format
+msgid "The persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implement <literal>Serializable</literal>."
+msgstr "你的持久化类<emphasis>必须</emphasis>覆盖 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法，来实现组合的标识符的相等判断。实现 <literal>Serializable</literal> 接口也是必须的。"
#. Tag: para
#: basic_mapping.xml:974
#, fuzzy, no-c-format
-msgid ""
-"Unfortunately, this approach means that a persistent object is its own "
-"identifier. There is no convenient \"handle\" other than the object itself. "
-"You must instantiate an instance of the persistent class itself and populate "
-"its identifier properties before you can <literal>load()</literal> the "
-"persistent state associated with a composite key. We call this approach an "
-"<emphasis>embedded</emphasis> composite identifier, and discourage it for "
-"serious applications."
-msgstr ""
-"不幸的是，这种组合关键字的方法意味着一个持久化类是它自己的标识。除了对象自己"
-"之外，没有什么方便的“把手”可用。你必须初始化持久化类的实例，填充它的标识符属"
-"性，再 <literal>load()</literal> 组合关键字关联的持久状态。我们把这种方法称"
-"为 <emphasis>embedded（嵌入式）</emphasis>的组合标识符，在重要的应用中不鼓励"
-"使用这种用法。"
+msgid "Unfortunately, this approach means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr "不幸的是，这种组合关键字的方法意味着一个持久化类是它自己的标识。除了对象自己之外，没有什么方便的“把手”可用。你必须初始化持久化类的实例，填充它的标识符属性，再 <literal>load()</literal> 组合关键字关联的持久状态。我们把这种方法称为 <emphasis>embedded（嵌入式）</emphasis>的组合标识符，在重要的应用中不鼓励使用这种用法。"
#. Tag: para
#: basic_mapping.xml:983
#, no-c-format
-msgid ""
-"A second approach is what we call a <emphasis>mapped</emphasis> composite "
-"identifier, where the identifier properties named inside the <literal><"
-"composite-id></literal> element are duplicated on both the persistent "
-"class and a separate identifier class."
-msgstr ""
-"第二种方法我们称为 <emphasis>mapped（映射式）</emphasis>组合标识符（mapped "
-"composite identifier），<literal><composite-id></literal> 元素中列出的"
-"标识属性不但在持久化类出现，还形成一个独立的标识符类。"
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal><composite-id></literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr "第二种方法我们称为 <emphasis>mapped（映射式）</emphasis>组合标识符（mapped composite identifier），<literal><composite-id></literal> 元素中列出的标识属性不但在持久化类出现，还形成一个独立的标识符类。"
#. Tag: programlisting
#: basic_mapping.xml:989
@@ -2007,19 +1333,8 @@
#. Tag: para
#: basic_mapping.xml:991
#, fuzzy, no-c-format
-msgid ""
-"In this example, both the composite identifier class, <literal>MedicareId</"
-"literal>, and the entity class itself have properties named "
-"<literal>medicareNumber</literal> and <literal>dependent</literal>. The "
-"identifier class must override <literal>equals()</literal> and "
-"<literal>hashCode()</literal> and implement <literal>Serializable</literal>. "
-"The main disadvantage of this approach is code duplication."
-msgstr ""
-"在这个例子中，组合标识符类 <literal>MedicareId</literal> 和实体类都含有 "
-"<literal>medicareNumber</literal> 和 <literal>dependent</literal> 属性。标识"
-"符类必须重载 <literal>equals()</literal> 和 <literal>hashCode()</literal> 并"
-"且实现 <literal>Serializable</literal> 接口。这种方法的缺点是出现了明显的代码"
-"重复。"
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement <literal>Serializable</literal>. The main disadvantage of this approach is code duplication."
+msgstr "在这个例子中，组合标识符类 <literal>MedicareId</literal> 和实体类都含有 <literal>medicareNumber</literal> 和 <literal>dependent</literal> 属性。标识符类必须重载 <literal>equals()</literal> 和 <literal>hashCode()</literal> 并且实现 <literal>Serializable</literal> 接口。这种方法的缺点是出现了明显的代码重复。"
#. Tag: para
#: basic_mapping.xml:1000
@@ -2030,81 +1345,50 @@
#. Tag: para
#: basic_mapping.xml:1006
#, fuzzy, no-c-format
-msgid ""
-"<literal>mapped</literal> (optional - defaults to <literal>false</literal>): "
-"indicates that a mapped composite identifier is used, and that the contained "
-"property mappings refer to both the entity class and the composite "
-"identifier class."
-msgstr ""
-"<literal>mapped</literal>（可选，默认为 <literal>false</literal>）：指明使用"
-"一个映射式组合标识符，其包含的属性映射同时在实体类和组合标识符类中出现。"
+msgid "<literal>mapped</literal> (optional - defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr "<literal>mapped</literal>（可选，默认为 <literal>false</literal>）：指明使用一个映射式组合标识符，其包含的属性映射同时在实体类和组合标识符类中出现。"
#. Tag: para
#: basic_mapping.xml:1014
#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal> (optional - but required for a mapped composite "
-"identifier): the class used as a composite identifier."
-msgstr ""
-"<literal>class</literal>（可选,但对映射式组合标识符必须指定）：作为组合标识符"
-"类使用的类名."
+msgid "<literal>class</literal> (optional - but required for a mapped composite identifier): the class used as a composite identifier."
+msgstr "<literal>class</literal>（可选,但对映射式组合标识符必须指定）：作为组合标识符类使用的类名."
#. Tag: para
#: basic_mapping.xml:1021
#, fuzzy, no-c-format
-msgid ""
-"We will describe a third, even more convenient approach, where the composite "
-"identifier is implemented as a component class in <xref linkend=\"components-"
-"compositeid\"/>. The attributes described below apply only to this "
-"alternative approach:"
-msgstr ""
-"在 <xref linkend=\"Component_Mapping-Components_as_composite_identifiers\"/> "
-"一节中,我们会描述第三种方式,那就是把组合标识符实现为一个组件（component）类,"
-"这是更方便的方法。下面的属性仅对第三种方法有效："
+msgid "We will describe a third, even more convenient approach, where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
+msgstr "在 <xref linkend=\"Component_Mapping-Components_as_composite_identifiers\"/> 一节中,我们会描述第三种方式,那就是把组合标识符实现为一个组件（component）类,这是更方便的方法。下面的属性仅对第三种方法有效："
#. Tag: para
#: basic_mapping.xml:1029
#, fuzzy, no-c-format
-msgid ""
-"<literal>name</literal> (optional - required for this approach): a property "
-"of component type that holds the composite identifier. Please see chapter 9 "
-"for more information."
-msgstr ""
-"<literal>name</literal>（可选,但对这种方法而言必须）：包含此组件标识符的组件"
-"类型的名字（参阅第9章）。"
+msgid "<literal>name</literal> (optional - required for this approach): a property of component type that holds the composite identifier. Please see chapter 9 for more information."
+msgstr "<literal>name</literal>（可选,但对这种方法而言必须）：包含此组件标识符的组件类型的名字（参阅第9章）。"
#. Tag: para
-#: basic_mapping.xml:1035 basic_mapping.xml:1256 basic_mapping.xml:1368
-#: basic_mapping.xml:1557 basic_mapping.xml:1731 basic_mapping.xml:1901
+#: basic_mapping.xml:1035
+#: basic_mapping.xml:1256
+#: basic_mapping.xml:1368
+#: basic_mapping.xml:1557
+#: basic_mapping.xml:1731
+#: basic_mapping.xml:1901
#: basic_mapping.xml:2480
#, fuzzy, no-c-format
-msgid ""
-"<literal>access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate uses for accessing the property value."
-msgstr ""
-"<literal>access</literal>（可选 — 默认为 <literal>property</literal>）："
-"Hibernate 用来访问属性值的策略。"
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate uses for accessing the property value."
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。"
#. Tag: para
#: basic_mapping.xml:1041
#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal> (optional - defaults to the property type "
-"determined by reflection): the component class used as a composite "
-"identifier. Please see the next section for more information."
-msgstr ""
-"<literal>class</literal>（可选 — 默认会用反射来自动判定属性类型 ）：用来作为"
-"组合标识符的组件类的类名（参阅下一节）"
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the component class used as a composite identifier. Please see the next section for more information."
+msgstr "<literal>class</literal>（可选 — 默认会用反射来自动判定属性类型 ）：用来作为组合标识符的组件类的类名（参阅下一节）"
#. Tag: para
#: basic_mapping.xml:1048
#, fuzzy, no-c-format
-msgid ""
-"The third approach, an <emphasis>identifier component</emphasis>, is "
-"recommended for almost all applications."
-msgstr ""
-"第三种方式，被称为 <emphasis>identifier component（标识符组件）</emphasis>是"
-"我们对几乎所有应用都推荐使用的方式。"
+msgid "The third approach, an <emphasis>identifier component</emphasis>, is recommended for almost all applications."
+msgstr "第三种方式，被称为 <emphasis>identifier component（标识符组件）</emphasis>是我们对几乎所有应用都推荐使用的方式。"
#. Tag: title
#: basic_mapping.xml:1056
@@ -2115,24 +1399,8 @@
#. Tag: para
#: basic_mapping.xml:1058
#, fuzzy, no-c-format
-msgid ""
-"The <literal><discriminator></literal> element is required for "
-"polymorphic persistence using the table-per-class-hierarchy mapping "
-"strategy. It declares a discriminator column of the table. The discriminator "
-"column contains marker values that tell the persistence layer what subclass "
-"to instantiate for a particular row. A restricted set of types can be used: "
-"<literal>string</literal>, <literal>character</literal>, <literal>integer</"
-"literal>, <literal>byte</literal>, <literal>short</literal>, "
-"<literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</"
-"literal>."
-msgstr ""
-"在\"一棵对象继承树对应一个表\"的策略中，<literal><discriminator></"
-"literal> 元素是必需的，它定义了表的鉴别器字段。鉴别器字段包含标志值，用于告知"
-"持久化层应该为某个特定的行创建哪一个子类的实例。如下这些受到限制的类型可以使"
-"用：<literal>string</literal>, <literal>character</literal>, "
-"<literal>integer</literal>, <literal>byte</literal>, <literal>short</"
-"literal>, <literal>boolean</literal>, <literal>yes_no</literal>, "
-"<literal>true_false</literal>。"
+msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy. It declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types can be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr "在\"一棵对象继承树对应一个表\"的策略中，<literal><discriminator></literal> 元素是必需的，它定义了表的鉴别器字段。鉴别器字段包含标志值，用于告知持久化层应该为某个特定的行创建哪一个子类的实例。如下这些受到限制的类型可以使用：<literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>。"
#. Tag: programlisting
#: basic_mapping.xml:1076
@@ -2157,91 +1425,50 @@
#. Tag: para
#: basic_mapping.xml:1079
#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to <literal>class</literal>): "
-"the name of the discriminator column."
-msgstr ""
-"<literal>column</literal>（可选 — 默认为 <literal>class</literal>）器字段的名"
-"字"
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>): the name of the discriminator column."
+msgstr "<literal>column</literal>（可选 — 默认为 <literal>class</literal>）器字段的名字"
#. Tag: para
#: basic_mapping.xml:1085
#, fuzzy, no-c-format
-msgid ""
-"<literal>type</literal> (optional - defaults to <literal>string</literal>): "
-"a name that indicates the Hibernate type"
-msgstr ""
-"<literal>type</literal>（可选 — 默认为 <literal>string</literal>）一个 "
-"Hibernate 字段类型的名字"
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>): a name that indicates the Hibernate type"
+msgstr "<literal>type</literal>（可选 — 默认为 <literal>string</literal>）一个 Hibernate 字段类型的名字"
#. Tag: para
#: basic_mapping.xml:1091
#, fuzzy, no-c-format
-msgid ""
-"<literal>force</literal> (optional - defaults to <literal>false</literal>): "
-"\"forces\" Hibernate to specify the allowed discriminator values, even when "
-"retrieving all instances of the root class."
-msgstr ""
-"<literal>force(强制)</literal>（可选 — 默认为 <literal>false</literal>）\"强"
-"制\" Hibernate 指定允许的鉴别器值,即使当取得的所有实例都是根类的。"
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>): \"forces\" Hibernate to specify the allowed discriminator values, even when retrieving all instances of the root class."
+msgstr "<literal>force(强制)</literal>（可选 — 默认为 <literal>false</literal>）\"强制\" Hibernate 指定允许的鉴别器值,即使当取得的所有实例都是根类的。"
#. Tag: para
#: basic_mapping.xml:1098
#, fuzzy, no-c-format
-msgid ""
-"<literal>insert</literal> (optional - defaults to <literal>true</literal>): "
-"set this to <literal>false</literal> if your discriminator column is also "
-"part of a mapped composite identifier. It tells Hibernate not to include the "
-"column in SQL <literal>INSERTs</literal>."
-msgstr ""
-"<literal>insert</literal>（可选 - 默认为<literal>true</literal>）如果你的鉴别"
-"器字段也是映射为复合标识（composite identifier）的一部分，则需将这个值设为 "
-"<literal>false</literal>。（告诉 Hibernate 在做 SQL <literal>INSERT</"
-"literal> 时不包含该列）"
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. It tells Hibernate not to include the column in SQL <literal>INSERTs</literal>."
+msgstr "<literal>insert</literal>（可选 - 默认为<literal>true</literal>）如果你的鉴别器字段也是映射为复合标识（composite identifier）的一部分，则需将这个值设为 <literal>false</literal>。（告诉 Hibernate 在做 SQL <literal>INSERT</literal> 时不包含该列）"
#. Tag: para
#: basic_mapping.xml:1106
#, fuzzy, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): an arbitrary SQL expression that is "
-"executed when a type has to be evaluated. It allows content-based "
-"discrimination."
-msgstr ""
-"<literal>formula</literal>（可选）一个 SQL 表达式，在类型判断（判断是父类还是"
-"具体子类 — 译注）时执行。可用于基于内容的鉴别器。"
+msgid "<literal>formula</literal> (optional): an arbitrary SQL expression that is executed when a type has to be evaluated. It allows content-based discrimination."
+msgstr "<literal>formula</literal>（可选）一个 SQL 表达式，在类型判断（判断是父类还是具体子类 — 译注）时执行。可用于基于内容的鉴别器。"
#. Tag: para
#: basic_mapping.xml:1114
#, no-c-format
-msgid ""
-"Actual values of the discriminator column are specified by the "
-"<literal>discriminator-value</literal> attribute of the <literal><"
-"class></literal> and <literal><subclass></literal> elements."
-msgstr ""
-"鉴别器字段的实际值是根据 <literal><class></literal> 和 <literal><"
-"subclass></literal> 元素中的 <literal>discriminator-value</literal> 属性得"
-"来的。"
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal><class></literal> and <literal><subclass></literal> elements."
+msgstr "鉴别器字段的实际值是根据 <literal><class></literal> 和 <literal><subclass></literal> 元素中的 <literal>discriminator-value</literal> 属性得来的。"
#. Tag: para
#: basic_mapping.xml:1120
#, fuzzy, no-c-format
-msgid ""
-"The <literal>force</literal> attribute is only useful if the table contains "
-"rows with \"extra\" discriminator values that are not mapped to a persistent "
-"class. This will not usually be the case."
-msgstr ""
-"<literal>force</literal> 属性仅仅在这种情况下有用的：表中包含没有被映射到持久"
-"化类的附加辨别器值。这种情况不会经常遇到。"
+msgid "The <literal>force</literal> attribute is only useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr "<literal>force</literal> 属性仅仅在这种情况下有用的：表中包含没有被映射到持久化类的附加辨别器值。这种情况不会经常遇到。"
#. Tag: para
#: basic_mapping.xml:1126
#, fuzzy, no-c-format
-msgid ""
-"The <literal>formula</literal> attribute allows you to declare an arbitrary "
-"SQL expression that will be used to evaluate the type of a row. For example:"
-msgstr ""
-"使用 <literal>formula</literal> 属性你可以定义一个 SQL 表达式，用来判断一个行"
-"数据的类型。"
+msgid "The <literal>formula</literal> attribute allows you to declare an arbitrary SQL expression that will be used to evaluate the type of a row. For example:"
+msgstr "使用 <literal>formula</literal> 属性你可以定义一个 SQL 表达式，用来判断一个行数据的类型。"
#. Tag: programlisting
#: basic_mapping.xml:1131
@@ -2264,15 +1491,8 @@
#. Tag: para
#: basic_mapping.xml:1138
#, fuzzy, no-c-format
-msgid ""
-"The <literal><version></literal> element is optional and indicates "
-"that the table contains versioned data. This is particularly useful if you "
-"plan to use <emphasis>long transactions</emphasis>. See below for more "
-"information:"
-msgstr ""
-"<literal><version></literal> 元素是可选的，表明表中包含附带版本信息的数"
-"据。这在你准备使用<emphasis> 长事务（long transactions）</emphasis>的时候特别"
-"有用。（见后）"
+msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis>. See below for more information:"
+msgstr "<literal><version></literal> 元素是可选的，表明表中包含附带版本信息的数据。这在你准备使用<emphasis> 长事务（long transactions）</emphasis>的时候特别有用。（见后）"
#. Tag: programlisting
#: basic_mapping.xml:1154
@@ -2303,9 +1523,7 @@
#. Tag: para
#: basic_mapping.xml:1157
#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of the column holding the version number."
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the column holding the version number."
msgstr "<literal>column</literal>（可选 — 默认为属性名）：指定持有版本号的字段名。"
#. Tag: para
@@ -2317,94 +1535,44 @@
#. Tag: para
#: basic_mapping.xml:1168
#, fuzzy, no-c-format
-msgid ""
-"<literal>type</literal> (optional - defaults to <literal>integer</literal>): "
-"the type of the version number."
-msgstr ""
-"<literal>type</literal>（可选 — 默认是 <literal>integer</literal>）：版本号的"
-"类型。"
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): the type of the version number."
+msgstr "<literal>type</literal>（可选 — 默认是 <literal>integer</literal>）：版本号的类型。"
#. Tag: para
#: basic_mapping.xml:1174
#, fuzzy, no-c-format
-msgid ""
-"<literal>access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate uses to access the property value."
-msgstr ""
-"<literal>access</literal>（可选 — 默认为 <literal>property</literal>）："
-"Hibernate 用来访问属性值的策略。"
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate uses to access the property value."
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。"
#. Tag: para
#: basic_mapping.xml:1180
#, fuzzy, no-c-format
-msgid ""
-"<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</"
-"literal>): a version property value that indicates that an instance is newly "
-"instantiated (unsaved), distinguishing it from detached instances that were "
-"saved or loaded in a previous session. <literal>Undefined</literal> "
-"specifies that the identifier property value should be used."
-msgstr ""
-"<literal>unsaved-value</literal>（可选 — 默认是 <literal>undefined</"
-"literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个"
-"值就可以把这种情况 和已经在先前的 session 中保存或装载的脱管（detached）实例"
-"区分开来。（<literal>undefined</literal> 指明应被使用的标识属性值。）"
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): a version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. <literal>Undefined</literal> specifies that the identifier property value should be used."
+msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>undefined</literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种情况 和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> 指明应被使用的标识属性值。）"
#. Tag: para
#: basic_mapping.xml:1189
#, fuzzy, no-c-format
-msgid ""
-"<literal>generated</literal> (optional - defaults to <literal>never</"
-"literal>): specifies that this version property value is generated by the "
-"database. See the discussion of <xref linkend=\"mapping-generated\"/> for "
-"more information."
-msgstr ""
-"<literal>generated</literal>（可选 — 默认是 <literal>never</literal>）：表明"
-"此版本属性值是否实际上是由数据库生成的。请参阅 <xref linkend="
-"\"Basic_OR_Mapping-Generated_Properties\"/> 部分的讨论。"
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this version property value is generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/> for more information."
+msgstr "<literal>generated</literal>（可选 — 默认是 <literal>never</literal>）：表明此版本属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-Generated_Properties\"/> 部分的讨论。"
#. Tag: para
#: basic_mapping.xml:1196
#, fuzzy, no-c-format
-msgid ""
-"<literal>insert</literal> (optional - defaults to <literal>true</literal>): "
-"specifies whether the version column should be included in SQL insert "
-"statements. It can be set to <literal>false</literal> if the database column "
-"is defined with a default value of <literal>0</literal>."
-msgstr ""
-"<literal>insert</literal>（可选 — 默认是 <literal>true</literal>）：表明此版"
-"本列应该包含在 SQL 插入语句中。只有当数据库字段有默认值 <literal>0</literal> "
-"的时候，才可以设置为 <literal>false</literal>。"
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): specifies whether the version column should be included in SQL insert statements. It can be set to <literal>false</literal> if the database column is defined with a default value of <literal>0</literal>."
+msgstr "<literal>insert</literal>（可选 — 默认是 <literal>true</literal>）：表明此版本列应该包含在 SQL 插入语句中。只有当数据库字段有默认值 <literal>0</literal> 的时候，才可以设置为 <literal>false</literal>。"
#. Tag: para
#: basic_mapping.xml:1206
#, fuzzy, no-c-format
-msgid ""
-"Version numbers can be of Hibernate type <literal>long</literal>, "
-"<literal>integer</literal>, <literal>short</literal>, <literal>timestamp</"
-"literal> or <literal>calendar</literal>."
-msgstr ""
-"版本号必须是以下类型：<literal>long</literal>，<literal>integer</literal>，"
-"<literal>short</literal>，<literal>timestamp</literal> 或者 "
-"<literal>calendar</literal>。"
+msgid "Version numbers can be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr "版本号必须是以下类型：<literal>long</literal>，<literal>integer</literal>，<literal>short</literal>，<literal>timestamp</literal> 或者 <literal>calendar</literal>。"
#. Tag: para
#: basic_mapping.xml:1211
#, fuzzy, no-c-format
-msgid ""
-"A version or timestamp property should never be null for a detached "
-"instance. Hibernate will detect any instance with a null version or "
-"timestamp as transient, irrespective of what other <literal>unsaved-value</"
-"literal> strategies are specified. <emphasis>Declaring a nullable version or "
-"timestamp property is an easy way to avoid problems with transitive "
-"reattachment in Hibernate. It is especially useful for people using assigned "
-"identifiers or composite keys</emphasis>."
-msgstr ""
-"一个脱管（detached）实例的 version 或 timestamp 属性不能为空（null），因为 "
-"Hibernate 不管 <literal>unsaved-value</literal> 被指定为何种策略，它将任何属"
-"性为空的 version 或 timestamp 实例看作为瞬时（transient）实例。 <emphasis>避"
-"免 Hibernate 中的传递重附（transitive reattachment）问题的一个简单方法是 定义"
-"一个不能为空的 version 或 timestamp 属性，特别是在人们使用程序分配的标识符"
-"（assigned identifiers） 或复合主键时非常有用！</emphasis>"
+msgid "A version or timestamp property should never be null for a detached instance. Hibernate will detect any instance with a null version or timestamp as transient, irrespective of what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid problems with transitive reattachment in Hibernate. It is especially useful for people using assigned identifiers or composite keys</emphasis>."
+msgstr "一个脱管（detached）实例的 version 或 timestamp 属性不能为空（null），因为 Hibernate 不管 <literal>unsaved-value</literal> 被指定为何种策略，它将任何属性为空的 version 或 timestamp 实例看作为瞬时（transient）实例。 <emphasis>避免 Hibernate 中的传递重附（transitive reattachment）问题的一个简单方法是 定义一个不能为空的 version 或 timestamp 属性，特别是在人们使用程序分配的标识符（assigned identifiers） 或复合主键时非常有用！</emphasis>"
#. Tag: title
#: basic_mapping.xml:1222
@@ -2415,15 +1583,8 @@
#. Tag: para
#: basic_mapping.xml:1224
#, fuzzy, no-c-format
-msgid ""
-"The optional <literal><timestamp></literal> element indicates that the "
-"table contains timestamped data. This provides an alternative to versioning. "
-"Timestamps are a less safe implementation of optimistic locking. However, "
-"sometimes the application might use the timestamps in other ways."
-msgstr ""
-"可选的 <literal><timestamp></literal> 元素指明了表中包含时间戳数据。这"
-"用来作为版本的替代。时间戳本质上是一种对乐观锁定的一种不是特别安全的实现。当"
-"然，有时候应用程序可能在其他方面使用时间戳。"
+msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This provides an alternative to versioning. Timestamps are a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr "可选的 <literal><timestamp></literal> 元素指明了表中包含时间戳数据。这用来作为版本的替代。时间戳本质上是一种对乐观锁定的一种不是特别安全的实现。当然，有时候应用程序可能在其他方面使用时间戳。"
#. Tag: programlisting
#: basic_mapping.xml:1240
@@ -2452,89 +1613,45 @@
#. Tag: para
#: basic_mapping.xml:1243
#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of a column holding the timestamp."
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of a column holding the timestamp."
msgstr "<literal>column</literal>（可选 — 默认为属性名）：持有时间戳的字段名。"
#. Tag: para
#: basic_mapping.xml:1249
#, fuzzy, no-c-format
-msgid ""
-"<literal>name</literal>: the name of a JavaBeans style property of Java type "
-"<literal>Date</literal> or <literal>Timestamp</literal> of the persistent "
-"class."
-msgstr ""
-"<literal>name</literal>：在持久化类中的 JavaBeans 风格的属性名，其 Java 类型"
-"是 <literal>Date</literal> 或者 <literal>Timestamp</literal> 的。"
+msgid "<literal>name</literal>: the name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr "<literal>name</literal>：在持久化类中的 JavaBeans 风格的属性名，其 Java 类型是 <literal>Date</literal> 或者 <literal>Timestamp</literal> 的。"
#. Tag: para
#: basic_mapping.xml:1262
#, fuzzy, no-c-format
-msgid ""
-"<literal>unsaved-value</literal> (optional - defaults to <literal>null</"
-"literal>): a version property value that indicates that an instance is newly "
-"instantiated (unsaved), distinguishing it from detached instances that were "
-"saved or loaded in a previous session. <literal>Undefined</literal> "
-"specifies that the identifier property value should be used."
-msgstr ""
-"<literal>unsaved-value</literal>（可选 — 默认是 <literal>null</literal>）：用"
-"于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种"
-"情况和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。"
-"（<literal>undefined</literal> 指明使用标识属性值进行这种判断。）"
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): a version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. <literal>Undefined</literal> specifies that the identifier property value should be used."
+msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>null</literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种情况和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> 指明使用标识属性值进行这种判断。）"
#. Tag: para
#: basic_mapping.xml:1271
#, fuzzy, no-c-format
-msgid ""
-"<literal>source</literal> (optional - defaults to <literal>vm</literal>): "
-"Where should Hibernate retrieve the timestamp value from? From the database, "
-"or from the current JVM? Database-based timestamps incur an overhead because "
-"Hibernate must hit the database in order to determine the \"next value\". It "
-"is safer to use in clustered environments. Not all <literal>Dialects</"
-"literal> are known to support the retrieval of the database's current "
-"timestamp. Others may also be unsafe for usage in locking due to lack of "
-"precision (Oracle 8, for example)."
-msgstr ""
-"<literal>source</literal>（可选 — 默认是 <literal>vm</literal>）：Hibernate "
-"如何才能获取到时间戳的值呢？从数据库，还是当前 JVM？从数据库获取会带来一些负"
-"担，因为 Hibernate 必须访问数据库来获得“下一个值”，但是在集群环境中会更安全"
-"些。还要注意，并不是所有的 <literal>Dialect（方言）</literal>都支持获得数据库"
-"的当前时间戳的，而支持的数据库中又有一部分因为精度不足，用于锁定是不安全的"
-"（例如 Oracle 8）。"
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): Where should Hibernate retrieve the timestamp value from? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\". It is safer to use in clustered environments. Not all <literal>Dialects</literal> are known to support the retrieval of the database's current timestamp. Others may also be unsafe for usage in locking due to lack of precision (Oracle 8, for example)."
+msgstr "<literal>source</literal>（可选 — 默认是 <literal>vm</literal>）：Hibernate 如何才能获取到时间戳的值呢？从数据库，还是当前 JVM？从数据库获取会带来一些负担，因为 Hibernate 必须访问数据库来获得“下一个值”，但是在集群环境中会更安全些。还要注意，并不是所有的 <literal>Dialect（方言）</literal>都支持获得数据库的当前时间戳的，而支持的数据库中又有一部分因为精度不足，用于锁定是不安全的（例如 Oracle 8）。"
#. Tag: para
#: basic_mapping.xml:1283
#, fuzzy, no-c-format
-msgid ""
-"<literal>generated</literal> (optional - defaults to <literal>never</"
-"literal>): specifies that this timestamp property value is actually "
-"generated by the database. See the discussion of <xref linkend=\"mapping-"
-"generated\"/> for more information."
-msgstr ""
-"<literal>generated</literal>（可选 - 默认是 <literal>never</literal>）：指出"
-"时间戳值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-"
-"Generated_Properties\"/> 的讨论。"
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/> for more information."
+msgstr "<literal>generated</literal>（可选 - 默认是 <literal>never</literal>）：指出时间戳值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-Generated_Properties\"/> 的讨论。"
#. Tag: title
-#: basic_mapping.xml:1294 basic_mapping.xml:2886
+#: basic_mapping.xml:1294
+#: basic_mapping.xml:2886
#, no-c-format
msgid "Note"
-msgstr ""
+msgstr "注意"
#. Tag: para
#: basic_mapping.xml:1295
#, fuzzy, no-c-format
-msgid ""
-"<literal><Timestamp></literal> is equivalent to <literal><version "
-"type=\"timestamp\"></literal>. And <literal><timestamp source=\"db"
-"\"></literal> is equivalent to <literal><version type=\"dbtimestamp"
-"\"></literal>"
-msgstr ""
-"注意，<literal><timestamp></literal> 和 <literal><version type="
-"\"timestamp\"></literal> 是等价的。并且 <literal><timestamp source=\"db"
-"\"></literal> 和 <literal><version type=\"dbtimestamp\"></literal> "
-"是等价的。"
+msgid "<literal><Timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
+msgstr "注意，<literal><timestamp></literal> 和 <literal><version type=\"timestamp\"></literal> 是等价的。并且 <literal><timestamp source=\"db\"></literal> 和 <literal><version type=\"dbtimestamp\"></literal> 是等价的。"
#. Tag: title
#: basic_mapping.xml:1307
@@ -2545,12 +1662,8 @@
#. Tag: para
#: basic_mapping.xml:1309
#, fuzzy, no-c-format
-msgid ""
-"The <literal><property></literal> element declares a persistent "
-"JavaBean style property of the class."
-msgstr ""
-"<literal><property></literal> 元素为类定义了一个持久化的、JavaBean 风格"
-"的属性。"
+msgid "The <literal><property></literal> element declares a persistent JavaBean style property of the class."
+msgstr "<literal><property></literal> 元素为类定义了一个持久化的、JavaBean 风格的属性。"
#. Tag: programlisting
#: basic_mapping.xml:1331
@@ -2601,108 +1714,57 @@
#. Tag: para
#: basic_mapping.xml:1334
#, no-c-format
-msgid ""
-"<literal>name</literal>: the name of the property, with an initial lowercase "
-"letter."
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
msgstr "<literal>name</literal>：属性的名字，以小写字母开头。"
#. Tag: para
#: basic_mapping.xml:1340
#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of the mapped database table column. This can also be specified by "
-"nested <literal><column></literal> element(s)."
-msgstr ""
-"<literal>column</literal>（可选 — 默认为属性名字）：对应的数据库字段名。 也可"
-"以通过嵌套的 <literal><column></literal> 元素指定。"
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This can also be specified by nested <literal><column></literal> element(s)."
+msgstr "<literal>column</literal>（可选 — 默认为属性名字）：对应的数据库字段名。 也可以通过嵌套的 <literal><column></literal> 元素指定。"
#. Tag: para
#: basic_mapping.xml:1352
#, fuzzy, no-c-format
-msgid ""
-"<literal>update, insert</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that the mapped columns should be included in SQL "
-"<literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. "
-"Setting both to <literal>false</literal> allows a pure \"derived\" property "
-"whose value is initialized from some other property that maps to the same "
-"column(s), or by a trigger or other application."
-msgstr ""
-"<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）： "
-"表明用于 <literal>UPDATE</literal> 和/或 <literal>INSERT</literal> 的 SQL 语"
-"句中是否包含这个被映射了的字段。这二者如果都设置为 <literal>false</literal> "
-"则表明这是一个“外源性（derived）”的属性，它的值来源于映射到同一个（或多个） "
-"字段的某些其他属性，或者通过一个 trigger（触发器）或其他程序生成。"
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>): specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same column(s), or by a trigger or other application."
+msgstr "<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）： 表明用于 <literal>UPDATE</literal> 和/或 <literal>INSERT</literal> 的 SQL 语句中是否包含这个被映射了的字段。这二者如果都设置为 <literal>false</literal> 则表明这是一个“外源性（derived）”的属性，它的值来源于映射到同一个（或多个） 字段的某些其他属性，或者通过一个 trigger（触发器）或其他程序生成。"
#. Tag: para
#: basic_mapping.xml:1361
#, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): an SQL expression that defines the "
-"value for a <emphasis>computed</emphasis> property. Computed properties do "
-"not have a column mapping of their own."
-msgstr ""
-"<literal>formula</literal>（可选）：一个 SQL 表达式，定义了这个<emphasis>计"
-"算 （computed）</emphasis> 属性的值。计算属性没有和它对应的数据库字段。"
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr "<literal>formula</literal>（可选）：一个 SQL 表达式，定义了这个<emphasis>计算 （computed）</emphasis> 属性的值。计算属性没有和它对应的数据库字段。"
#. Tag: para
#: basic_mapping.xml:1374
#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>false</literal>): "
-"specifies that this property should be fetched lazily when the instance "
-"variable is first accessed. It requires build-time bytecode instrumentation."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认为 <literal>false</literal>）：指定 指定"
-"实例变量第一次被访问时，这个属性是否延迟抓取（fetched lazily）（ 需要运行时字"
-"节码增强）。"
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): specifies that this property should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation."
+msgstr "<literal>lazy</literal>（可选 — 默认为 <literal>false</literal>）：指定 指定实例变量第一次被访问时，这个属性是否延迟抓取（fetched lazily）（ 需要运行时字节码增强）。"
#. Tag: para
#: basic_mapping.xml:1381
#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional): enables the DDL generation of a unique "
-"constraint for the columns. Also, allow this to be the target of a "
-"<literal>property-ref</literal>."
-msgstr ""
-"<literal>unique</literal>（可选）：使用 DDL 为该字段添加唯一的约束。同样，允"
-"许它作为 <literal>property-ref</literal> 引用的目标。"
+msgid "<literal>unique</literal> (optional): enables the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr "<literal>unique</literal>（可选）：使用 DDL 为该字段添加唯一的约束。同样，允许它作为 <literal>property-ref</literal> 引用的目标。"
#. Tag: para
#: basic_mapping.xml:1388
#, fuzzy, no-c-format
-msgid ""
-"<literal>not-null</literal> (optional): enables the DDL generation of a "
-"nullability constraint for the columns."
-msgstr ""
-"<literal>not-null</literal>（可选）：使用 DDL 为该字段添加可否为空"
-"（nullability）的约束。"
+msgid "<literal>not-null</literal> (optional): enables the DDL generation of a nullability constraint for the columns."
+msgstr "<literal>not-null</literal>（可选）：使用 DDL 为该字段添加可否为空（nullability）的约束。"
#. Tag: para
-#: basic_mapping.xml:1394 basic_mapping.xml:1577
+#: basic_mapping.xml:1394
+#: basic_mapping.xml:1577
#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to this property do or do not require "
-"acquisition of the optimistic lock. In other words, it determines if a "
-"version increment should occur when this property is dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认为 <literal>true</literal>）："
-"指定这个属性在做更新时是否需要获得乐观锁定（optimistic lock）。换句话说，它决"
-"定这个属性发生脏数据时版本（version）的值是否增长。"
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, it determines if a version increment should occur when this property is dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认为 <literal>true</literal>）：指定这个属性在做更新时是否需要获得乐观锁定（optimistic lock）。换句话说，它决定这个属性发生脏数据时版本（version）的值是否增长。"
#. Tag: para
#: basic_mapping.xml:1402
#, fuzzy, no-c-format
-msgid ""
-"<literal>generated</literal> (optional - defaults to <literal>never</"
-"literal>): specifies that this property value is actually generated by the "
-"database. See the discussion of <xref linkend=\"mapping-generated\"/> for "
-"more information."
-msgstr ""
-"<literal>generated</literal>（可选 — 默认为 <literal>never</literal>）：表明"
-"此属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-"
-"Generated_Properties\"/> 的讨论。"
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/> for more information."
+msgstr "<literal>generated</literal>（可选 — 默认为 <literal>never</literal>）：表明此属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-Generated_Properties\"/> 的讨论。"
#. Tag: para
#: basic_mapping.xml:1411
@@ -2713,24 +1775,14 @@
#. Tag: para
#: basic_mapping.xml:1417
#, fuzzy, no-c-format
-msgid ""
-"The name of a Hibernate basic type: <literal>integer, string, character, "
-"date, timestamp, float, binary, serializable, object, blob</literal> etc."
-msgstr ""
-"Hibernate 基本类型名（比如：<literal>integer, string, character,date, "
-"timestamp, float, binary, serializable, object, blob</literal>）。"
+msgid "The name of a Hibernate basic type: <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal> etc."
+msgstr "Hibernate 基本类型名（比如：<literal>integer, string, character,date, timestamp, float, binary, serializable, object, blob</literal>）。"
#. Tag: para
#: basic_mapping.xml:1423
#, fuzzy, no-c-format
-msgid ""
-"The name of a Java class with a default basic type: <literal>int, float, "
-"char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</"
-"literal> etc."
-msgstr ""
-"一个 Java 类的名字，这个类属于一种默认基础类型（比如：<literal>int, float,"
-"char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</"
-"literal>)。"
+msgid "The name of a Java class with a default basic type: <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal> etc."
+msgstr "一个 Java 类的名字，这个类属于一种默认基础类型（比如：<literal>int, float,char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)。"
#. Tag: para
#: basic_mapping.xml:1429
@@ -2741,62 +1793,26 @@
#. Tag: para
#: basic_mapping.xml:1434
#, fuzzy, no-c-format
-msgid ""
-"The class name of a custom type: <literal>com.illflow.type.MyCustomType</"
-"literal> etc."
-msgstr ""
-"一个自定义类型的类的名字。（比如：<literal>com.illflow.type.MyCustomType</"
-"literal>)。"
+msgid "The class name of a custom type: <literal>com.illflow.type.MyCustomType</literal> etc."
+msgstr "一个自定义类型的类的名字。（比如：<literal>com.illflow.type.MyCustomType</literal>)。"
#. Tag: para
#: basic_mapping.xml:1440
#, fuzzy, no-c-format
-msgid ""
-"If you do not specify a type, Hibernate will use reflection upon the named "
-"property and guess the correct Hibernate type. Hibernate will attempt to "
-"interpret the name of the return class of the property getter using, in "
-"order, rules 2, 3, and 4. In certain cases you will need the <literal>type</"
-"literal> attribute. For example, to distinguish between <literal>Hibernate."
-"DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a "
-"custom type."
-msgstr ""
-"如果你没有指定类型，Hibernarte 会使用反射来得到这个名字的属性，以此来猜测正确"
-"的 Hibernate 类型。Hibernate 会按照规则 2，3，4 的顺序对属性读取器（getter方"
-"法）的返回类进行解释。然而，这还不够。 在某些情况下你仍然需要 <literal>type</"
-"literal> 属性。（比如，为了区别<literal>Hibernate.DATE</literal> 和"
-"<literal>Hibernate.TIMESTAMP</literal>,或者为了指定一个自定义类型。）"
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property and guess the correct Hibernate type. Hibernate will attempt to interpret the name of the return class of the property getter using, in order, rules 2, 3, and 4. In certain cases you will need the <literal>type</literal> attribute. For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type."
+msgstr "如果你没有指定类型，Hibernarte 会使用反射来得到这个名字的属性，以此来猜测正确的 Hibernate 类型。Hibernate 会按照规则 2，3，4 的顺序对属性读取器（getter方法）的返回类进行解释。然而，这还不够。 在某些情况下你仍然需要 <literal>type</literal> 属性。（比如，为了区别<literal>Hibernate.DATE</literal> 和<literal>Hibernate.TIMESTAMP</literal>,或者为了指定一个自定义类型。）"
#. Tag: para
#: basic_mapping.xml:1450
#, fuzzy, no-c-format
-msgid ""
-"The <literal>access</literal> attribute allows you to control how Hibernate "
-"accesses the property at runtime. By default, Hibernate will call the "
-"property get/set pair. If you specify <literal>access=\"field\"</literal>, "
-"Hibernate will bypass the get/set pair and access the field directly using "
-"reflection. You can specify your own strategy for property access by naming "
-"a class that implements the interface <literal>org.hibernate.property."
-"PropertyAccessor</literal>."
-msgstr ""
-"<literal>access</literal> 属性用来让你控制 Hibernate 如何在运行时访问属性。在"
-"默认情况下，Hibernate 会使用属性的 get/set 方法对（pair）。如果你指明 "
-"<literal>access=\"field\"</literal>，Hibernate 会忽略 get/set 方法对，直接使"
-"用反射来访问成员变量。你也可以指定你自己的策略，这就需要你自己实现 "
-"<literal>org.hibernate.property.PropertyAccessor</literal> 接口，再在 access "
-"中设置你自定义策略类的名字。"
+msgid "The <literal>access</literal> attribute allows you to control how Hibernate accesses the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly using reflection. You can specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr "<literal>access</literal> 属性用来让你控制 Hibernate 如何在运行时访问属性。在默认情况下，Hibernate 会使用属性的 get/set 方法对（pair）。如果你指明 <literal>access=\"field\"</literal>，Hibernate 会忽略 get/set 方法对，直接使用反射来访问成员变量。你也可以指定你自己的策略，这就需要你自己实现 <literal>org.hibernate.property.PropertyAccessor</literal> 接口，再在 access 中设置你自定义策略类的名字。"
#. Tag: para
#: basic_mapping.xml:1459
#, fuzzy, no-c-format
-msgid ""
-"A powerful feature is derived properties. These properties are by definition "
-"read-only. The property value is computed at load time. You declare the "
-"computation as an SQL expression. This then translates to a <literal>SELECT</"
-"literal> clause subquery in the SQL query that loads an instance:"
-msgstr ""
-"衍生属性（derive propertie）是一个特别强大的特征。这些属性应该定义为只读，属"
-"性值在装载时计算生成。 你用一个 SQL 表达式生成计算的结果，它会在这个实例转载"
-"时翻译成一个 SQL 查询的 <literal>SELECT</literal> 子查询语句。"
+msgid "A powerful feature is derived properties. These properties are by definition read-only. The property value is computed at load time. You declare the computation as an SQL expression. This then translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr "衍生属性（derive propertie）是一个特别强大的特征。这些属性应该定义为只读，属性值在装载时计算生成。 你用一个 SQL 表达式生成计算的结果，它会在这个实例转载时翻译成一个 SQL 查询的 <literal>SELECT</literal> 子查询语句。"
#. Tag: programlisting
#: basic_mapping.xml:1466
@@ -2804,15 +1820,13 @@
msgid ""
"<![CDATA[\n"
"<property name=\"totalPrice\"\n"
-" formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product "
-"p\n"
+" formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
" WHERE li.productId = p.productId\n"
" AND li.customerId = customerId\n"
" AND li.orderNumber = orderNumber )\"/>]]>"
msgstr ""
"<property name=\"totalPrice\"\n"
-" formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product "
-"p\n"
+" formula=\"( SELECT SUM (li.quantity*p.price) FROM LineItem li, Product p\n"
" WHERE li.productId = p.productId\n"
" AND li.customerId = customerId\n"
" AND li.orderNumber = orderNumber )\"/>"
@@ -2820,15 +1834,8 @@
#. Tag: para
#: basic_mapping.xml:1468
#, fuzzy, no-c-format
-msgid ""
-"You can reference the entity table by not declaring an alias on a particular "
-"column. This would be <literal>customerId</literal> in the given example. "
-"You can also use the nested <literal><formula></literal> mapping "
-"element if you do not want to use the attribute."
-msgstr ""
-"注意，你可以使用实体自己的表，而不用为这个特别的列定义别名（上面例子中的"
-"<literal>customerId</literal>）。同时注意，如果你不喜欢使用属性， 你可以使用"
-"嵌套的 <literal><formula></literal> 映射元素。"
+msgid "You can reference the entity table by not declaring an alias on a particular column. This would be <literal>customerId</literal> in the given example. You can also use the nested <literal><formula></literal> mapping element if you do not want to use the attribute."
+msgstr "注意，你可以使用实体自己的表，而不用为这个特别的列定义别名（上面例子中的<literal>customerId</literal>）。同时注意，如果你不喜欢使用属性， 你可以使用嵌套的 <literal><formula></literal> 映射元素。"
#. Tag: title
#: basic_mapping.xml:1478
@@ -2839,15 +1846,8 @@
#. Tag: para
#: basic_mapping.xml:1480
#, fuzzy, no-c-format
-msgid ""
-"An ordinary association to another persistent class is declared using a "
-"<literal>many-to-one</literal> element. The relational model is a many-to-"
-"one association; a foreign key in one table is referencing the primary key "
-"column(s) of the target table."
-msgstr ""
-"通过 <literal>many-to-one</literal> 元素,可以定义一种常见的与另一个持久化类的"
-"关联。这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外"
-"键引用目标表的主键字段。"
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association; a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr "通过 <literal>many-to-one</literal> 元素,可以定义一种常见的与另一个持久化类的关联。这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外键引用目标表的主键字段。"
#. Tag: programlisting
#: basic_mapping.xml:1508
@@ -2902,174 +1902,95 @@
"/>"
#. Tag: para
-#: basic_mapping.xml:1511 basic_mapping.xml:1692 basic_mapping.xml:1878
+#: basic_mapping.xml:1511
+#: basic_mapping.xml:1692
+#: basic_mapping.xml:1878
#, fuzzy, no-c-format
msgid "<literal>name</literal>: the name of the property."
msgstr "<literal>name</literal>：属性名"
#. Tag: para
-#: basic_mapping.xml:1516 basic_mapping.xml:2307
+#: basic_mapping.xml:1516
+#: basic_mapping.xml:2307
#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional): the name of the foreign key column. "
-"This can also be specified by nested <literal><column></literal> "
-"element(s)."
-msgstr ""
-"<literal>column</literal>（可选）：外键字段的名称。也可以通过嵌套的 "
-"<literal><column></literal> 指定。"
+msgid "<literal>column</literal> (optional): the name of the foreign key column. This can also be specified by nested <literal><column></literal> element(s)."
+msgstr "<literal>column</literal>（可选）：外键字段的名称。也可以通过嵌套的 <literal><column></literal> 指定。"
#. Tag: para
-#: basic_mapping.xml:1523 basic_mapping.xml:1697
+#: basic_mapping.xml:1523
+#: basic_mapping.xml:1697
#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal> (optional - defaults to the property type "
-"determined by reflection): the name of the associated class."
-msgstr ""
-"<literal>class</literal>（可选 — 默认是通过反射得到的属性类型）：被关联的类的"
-"名字。"
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the name of the associated class."
+msgstr "<literal>class</literal>（可选 — 默认是通过反射得到的属性类型）：被关联的类的名字。"
#. Tag: para
-#: basic_mapping.xml:1529 basic_mapping.xml:1703
+#: basic_mapping.xml:1529
+#: basic_mapping.xml:1703
#, fuzzy, no-c-format
-msgid ""
-"<literal>cascade</literal> (optional): specifies which operations should be "
-"cascaded from the parent object to the associated object."
-msgstr ""
-"<literal>cascade（级联）</literal>（可选）表明操作是否从父对象级联到被关联的"
-"对象。"
+msgid "<literal>cascade</literal> (optional): specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "<literal>cascade（级联）</literal>（可选）表明操作是否从父对象级联到被关联的对象。"
#. Tag: para
-#: basic_mapping.xml:1535 basic_mapping.xml:1718
+#: basic_mapping.xml:1535
+#: basic_mapping.xml:1718
#, fuzzy, no-c-format
-msgid ""
-"<literal>fetch</literal> (optional - defaults to <literal>select</literal>): "
-"chooses between outer-join fetching or sequential select fetching."
-msgstr ""
-"<literal>fetch</literal>（可选 — 默认为 <literal>select</literal>）：在外连接"
-"抓取（outer-join fetching）和序列选择抓取（sequential select fetching）两者中"
-"选择其一。"
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): chooses between outer-join fetching or sequential select fetching."
+msgstr "<literal>fetch</literal>（可选 — 默认为 <literal>select</literal>）：在外连接抓取（outer-join fetching）和序列选择抓取（sequential select fetching）两者中选择其一。"
#. Tag: para
#: basic_mapping.xml:1541
#, fuzzy, no-c-format
-msgid ""
-"<literal>update, insert</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that the mapped columns should be included in SQL "
-"<literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. "
-"Setting both to <literal>false</literal> allows a pure \"derived\" "
-"association whose value is initialized from another property that maps to "
-"the same column(s), or by a trigger or other application."
-msgstr ""
-"<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）指"
-"定对应的字段是否包含在用于 <literal>UPDATE</literal> 和/或 <literal>INSERT</"
-"literal> 的 SQL 语句中。如果二者都是<literal>false</literal>,则这是一个纯粹"
-"的 “外源性（derived）”关联，它的值是通过映射到同一个（或多个）字段的某些其他"
-"属性得到 或者通过 trigger（触发器）、或其他程序生成。"
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>): specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from another property that maps to the same column(s), or by a trigger or other application."
+msgstr "<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）指定对应的字段是否包含在用于 <literal>UPDATE</literal> 和/或 <literal>INSERT</literal> 的 SQL 语句中。如果二者都是<literal>false</literal>,则这是一个纯粹的 “外源性（derived）”关联，它的值是通过映射到同一个（或多个）字段的某些其他属性得到 或者通过 trigger（触发器）、或其他程序生成。"
#. Tag: para
#: basic_mapping.xml:1550
#, fuzzy, no-c-format
-msgid ""
-"<literal>property-ref</literal> (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</literal>：（可选）被关联到此外键的类中的对应属性的名"
-"字。如果没有指定，被关联类的主键将被使用。"
+msgid "<literal>property-ref</literal> (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</literal>：（可选）被关联到此外键的类中的对应属性的名字。如果没有指定，被关联类的主键将被使用。"
#. Tag: para
#: basic_mapping.xml:1563
#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional): enables the DDL generation of a unique "
-"constraint for the foreign-key column. By allowing this to be the target of "
-"a <literal>property-ref</literal>, you can make the association multiplicity "
-"one-to-one."
-msgstr ""
-"<literal>unique</literal>（可选）：使用 DDL 为外键字段生成一个唯一约束。此"
-"外， 这也可以用作 <literal>property-ref</literal> 的目标属性。这使关联同时具"
-"有一对一的效果。"
+msgid "<literal>unique</literal> (optional): enables the DDL generation of a unique constraint for the foreign-key column. By allowing this to be the target of a <literal>property-ref</literal>, you can make the association multiplicity one-to-one."
+msgstr "<literal>unique</literal>（可选）：使用 DDL 为外键字段生成一个唯一约束。此外， 这也可以用作 <literal>property-ref</literal> 的目标属性。这使关联同时具有一对一的效果。"
#. Tag: para
#: basic_mapping.xml:1571
#, fuzzy, no-c-format
-msgid ""
-"<literal>not-null</literal> (optional): enables the DDL generation of a "
-"nullability constraint for the foreign key columns."
+msgid "<literal>not-null</literal> (optional): enables the DDL generation of a nullability constraint for the foreign key columns."
msgstr "<literal>not-null</literal>（可选）：使用 DDL 为外键字段生成一个非空约束。"
#. Tag: para
#: basic_mapping.xml:1585
#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): "
-"by default, single point associations are proxied. <literal>lazy=\"no-proxy"
-"\"</literal> specifies that the property should be fetched lazily when the "
-"instance variable is first accessed. This requires build-time bytecode "
-"instrumentation. <literal>lazy=\"false\"</literal> specifies that the "
-"association will always be eagerly fetched."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况"
-"下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal> 指定此属性应该"
-"在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增"
-"强）。<literal>lazy=\"false\"</literal> 指定此关联总是被预先抓取。"
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): by default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed. This requires build-time bytecode instrumentation. <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr "<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal> 指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增强）。<literal>lazy=\"false\"</literal> 指定此关联总是被预先抓取。"
#. Tag: para
#: basic_mapping.xml:1595
#, fuzzy, no-c-format
-msgid ""
-"<literal>not-found</literal> (optional - defaults to <literal>exception</"
-"literal>): specifies how foreign keys that reference missing rows will be "
-"handled. <literal>ignore</literal> will treat a missing row as a null "
-"association."
-msgstr ""
-"<literal>not-found</literal>（可选 - 默认为<literal>exception</literal>）：指"
-"定如何处理引用缺失行的外键：<literal>ignore</literal> 会把缺失的行作为一个空"
-"关联处理。"
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): specifies how foreign keys that reference missing rows will be handled. <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>not-found</literal>（可选 - 默认为<literal>exception</literal>）：指定如何处理引用缺失行的外键：<literal>ignore</literal> 会把缺失的行作为一个空关联处理。"
#. Tag: para
-#: basic_mapping.xml:1602 basic_mapping.xml:1756
+#: basic_mapping.xml:1602
+#: basic_mapping.xml:1756
#, fuzzy, no-c-format
-msgid ""
-"<literal>entity-name</literal> (optional): the entity name of the associated "
-"class."
+msgid "<literal>entity-name</literal> (optional): the entity name of the associated class."
msgstr "<literal>entity-name</literal>（可选）：被关联的类的实体名。"
#. Tag: para
#: basic_mapping.xml:1607
#, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): an SQL expression that defines the "
-"value for a <emphasis>computed</emphasis> foreign key."
-msgstr ""
-"<literal>formula</literal>（可选）：SQL 表达式，用于定义 <emphasis>computed"
-"（计算出的）</emphasis>外键值。"
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr "<literal>formula</literal>（可选）：SQL 表达式，用于定义 <emphasis>computed（计算出的）</emphasis>外键值。"
#. Tag: para
#: basic_mapping.xml:1615
#, fuzzy, no-c-format
-msgid ""
-"Setting a value of the <literal>cascade</literal> attribute to any "
-"meaningful value other than <literal>none</literal> will propagate certain "
-"operations to the associated object. The meaningful values are divided into "
-"three categories. First, basic operations, which include: <literal>persist, "
-"merge, delete, save-update, evict, replicate, lock and refresh</literal>; "
-"second, special values: <literal>delete-orphan</literal>; and third,"
-"<literal>all</literal> comma-separated combinations of operation names: "
-"<literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,"
-"delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> "
-"for a full explanation. Note that single valued, many-to-one and one-to-one, "
-"associations do not support orphan delete."
-msgstr ""
-"<literal>cascade</literal> 属性设置为除了<literal>none</literal> 以外任何有意"
-"义的值，它将把特定的操作传递到关联对象中。这个值就代表着 Hibernate 基本操作的"
-"名称，<literal>persist, merge, delete, save-update, evict, replicate, lock, "
-"refresh</literal>，以及特别的值 <literal>delete-orphan</literal> 和 "
-"<literal>all</literal>，并且可以用逗号分隔符来组合这些操作，例如，"
-"<literal>cascade=\"persist,merge,evict\"</literal> 或 <literal>cascade="
-"\"all,delete-orphan\"</literal>。更全面的解释请参考 <xref linkend="
-"\"Working_with_objects-Transitive_persistence\"/>。注意，单值关联（many-to-"
-"one 和 one-to-one 关联）不支持删除孤儿（orphan delete，删除不再被引用的值）。"
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are divided into three categories. First, basic operations, which include: <literal>persist, merge, delete, save-update, evict, replicate, lock and refresh</literal>; second, special values: <literal>delete-orphan</literal>; and third,<literal>all</literal> comma-separated combinations of operation names: <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\"/> for a full explanation. Note that single valued, many-to-one and one-to-one, associations do not support orphan delete."
+msgstr "<literal>cascade</literal> 属性设置为除了<literal>none</literal> 以外任何有意义的值，它将把特定的操作传递到关联对象中。这个值就代表着 Hibernate 基本操作的名称，<literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>，以及特别的值 <literal>delete-orphan</literal> 和 <literal>all</literal>，并且可以用逗号分隔符来组合这些操作，例如，<literal>cascade=\"persist,merge,evict\"</literal> 或 <literal>cascade=\"all,delete-orphan\"</literal>。更全面的解释请参考 <xref linkend=\"Working_with_objects-Transitive_persistence\"/>。注意，单值关联（many-to-one 和 one-to-one 关联）不支持删除孤儿（orphan delete，删除不再被引用的值）。"
#. Tag: para
#: basic_mapping.xml:1628
@@ -3080,38 +2001,20 @@
#. Tag: programlisting
#: basic_mapping.xml:1632
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID"
-"\"/>]]>"
+msgid "<![CDATA[<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>]]>"
msgstr "<many-to-one name=\"product\" class=\"Product\" column=\"PRODUCT_ID\"/>"
#. Tag: para
#: basic_mapping.xml:1634
#, fuzzy, no-c-format
-msgid ""
-"The <literal>property-ref</literal> attribute should only be used for "
-"mapping legacy data where a foreign key refers to a unique key of the "
-"associated table other than the primary key. This is a complicated and "
-"confusing relational model. For example, if the <literal>Product</literal> "
-"class had a unique serial number that is not the primary key. The "
-"<literal>unique</literal> attribute controls Hibernate's DDL generation with "
-"the SchemaExport tool."
-msgstr ""
-"<literal>property-ref</literal> 属性只应该用来对付遗留下来的数据库系统，可能"
-"有外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况下。这"
-"是一种十分丑陋的关系模型。比如说，假设 <literal>Product</literal> 类有一个惟"
-"一的序列号，它并不是主键。（<literal>unique</literal> 属性控制 Hibernate 通"
-"过 SchemaExport 工具进行的 DDL 生成。）"
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is a complicated and confusing relational model. For example, if the <literal>Product</literal> class had a unique serial number that is not the primary key. The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool."
+msgstr "<literal>property-ref</literal> 属性只应该用来对付遗留下来的数据库系统，可能有外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况下。这是一种十分丑陋的关系模型。比如说，假设 <literal>Product</literal> 类有一个惟一的序列号，它并不是主键。（<literal>unique</literal> 属性控制 Hibernate 通过 SchemaExport 工具进行的 DDL 生成。）"
#. Tag: programlisting
#: basic_mapping.xml:1643
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" "
-"column=\"SERIAL_NUMBER\"/>]]>"
-msgstr ""
-"<property name=\"serialNumber\" unique=\"true\" type=\"string\" column="
-"\"SERIAL_NUMBER\"/>"
+msgid "<![CDATA[<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>]]>"
+msgstr "<property name=\"serialNumber\" unique=\"true\" type=\"string\" column=\"SERIAL_NUMBER\"/>"
#. Tag: para
#: basic_mapping.xml:1645
@@ -3122,12 +2025,8 @@
#. Tag: programlisting
#: basic_mapping.xml:1649
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column="
-"\"PRODUCT_SERIAL_NUMBER\"/>]]>"
-msgstr ""
-"<many-to-one name=\"product\" property-ref=\"serialNumber\" column="
-"\"PRODUCT_SERIAL_NUMBER\"/>"
+msgid "<![CDATA[<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>]]>"
+msgstr "<many-to-one name=\"product\" property-ref=\"serialNumber\" column=\"PRODUCT_SERIAL_NUMBER\"/>"
#. Tag: para
#: basic_mapping.xml:1651
@@ -3138,31 +2037,20 @@
#. Tag: para
#: basic_mapping.xml:1655
#, no-c-format
-msgid ""
-"If the referenced unique key comprises multiple properties of the associated "
-"entity, you should map the referenced properties inside a named <literal><"
-"properties></literal> element."
-msgstr ""
-"如果被引用的唯一主键由关联实体的多个属性组成，你应该在名称为 <literal><"
-"properties></literal> 的元素 里面映射所有关联的属性。"
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal><properties></literal> element."
+msgstr "如果被引用的唯一主键由关联实体的多个属性组成，你应该在名称为 <literal><properties></literal> 的元素 里面映射所有关联的属性。"
#. Tag: para
#: basic_mapping.xml:1660
#, fuzzy, no-c-format
-msgid ""
-"If the referenced unique key is the property of a component, you can specify "
-"a property path:"
+msgid "If the referenced unique key is the property of a component, you can specify a property path:"
msgstr "假若被引用的唯一主键是组件的属性，你可以指定属性路径："
#. Tag: programlisting
#: basic_mapping.xml:1664
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column="
-"\"OWNER_SSN\"/>]]>"
-msgstr ""
-"<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column="
-"\"OWNER_SSN\"/>"
+msgid "<![CDATA[<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>]]>"
+msgstr "<many-to-one name=\"owner\" property-ref=\"identity.ssn\" column=\"OWNER_SSN\"/>"
#. Tag: title
#: basic_mapping.xml:1669
@@ -3173,12 +2061,8 @@
#. Tag: para
#: basic_mapping.xml:1671
#, no-c-format
-msgid ""
-"A one-to-one association to another persistent class is declared using a "
-"<literal>one-to-one</literal> element."
-msgstr ""
-"持久化对象之间一对一的关联关系是通过 <literal>one-to-one</literal> 元素定义"
-"的。"
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr "持久化对象之间一对一的关联关系是通过 <literal>one-to-one</literal> 元素定义的。"
#. Tag: programlisting
#: basic_mapping.xml:1689
@@ -3219,64 +2103,26 @@
#. Tag: para
#: basic_mapping.xml:1709
#, fuzzy, no-c-format
-msgid ""
-"<literal>constrained</literal> (optional): specifies that a foreign key "
-"constraint on the primary key of the mapped table and references the table "
-"of the associated class. This option affects the order in which <literal>save"
-"()</literal> and <literal>delete()</literal> are cascaded, and determines "
-"whether the association can be proxied. It is also used by the schema export "
-"tool."
-msgstr ""
-"<literal>constrained（约束）</literal>（可选）表明该类对应的表对应的数据库"
-"表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个"
-"选项影响 <literal>save()</literal> 和 <literal>delete()</literal> 在级联执行"
-"时的先后顺序以及决定该关联能否被委托（也在 schema export tool 中被使用）。"
+msgid "<literal>constrained</literal> (optional): specifies that a foreign key constraint on the primary key of the mapped table and references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association can be proxied. It is also used by the schema export tool."
+msgstr "<literal>constrained（约束）</literal>（可选）表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响 <literal>save()</literal> 和 <literal>delete()</literal> 在级联执行时的先后顺序以及决定该关联能否被委托（也在 schema export tool 中被使用）。"
#. Tag: para
#: basic_mapping.xml:1724
#, fuzzy, no-c-format
-msgid ""
-"<literal>property-ref</literal> (optional): the name of a property of the "
-"associated class that is joined to the primary key of this class. If not "
-"specified, the primary key of the associated class is used."
-msgstr ""
-"<literal>property-ref</literal>：（可选）指定关联类的属性名，这个属性将会和本"
-"类的主键相对应。如果没有指定，会使用对方关联类的主键。"
+msgid "<literal>property-ref</literal> (optional): the name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr "<literal>property-ref</literal>：（可选）指定关联类的属性名，这个属性将会和本类的主键相对应。如果没有指定，会使用对方关联类的主键。"
#. Tag: para
#: basic_mapping.xml:1737
#, fuzzy, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): almost all one-to-one associations "
-"map to the primary key of the owning entity. If this is not the case, you "
-"can specify another column, columns or expression to join on using an SQL "
-"formula. See <literal>org.hibernate.test.onetooneformula</literal> for an "
-"example."
-msgstr ""
-"<literal>formula </literal>（可选）：绝大多数一对一的关联都指向其实体的主键。"
-"在一些少见的情况中，你可能会指向其他的一个或多个字段，或者是一个表达式，这些"
-"情况下，你可以用一个 SQL 公式来表示。（可以在 org.hibernate.test."
-"onetooneformula 找到例子）"
+msgid "<literal>formula</literal> (optional): almost all one-to-one associations map to the primary key of the owning entity. If this is not the case, you can specify another column, columns or expression to join on using an SQL formula. See <literal>org.hibernate.test.onetooneformula</literal> for an example."
+msgstr "<literal>formula </literal>（可选）：绝大多数一对一的关联都指向其实体的主键。在一些少见的情况中，你可能会指向其他的一个或多个字段，或者是一个表达式，这些情况下，你可以用一个 SQL 公式来表示。（可以在 org.hibernate.test.onetooneformula 找到例子）"
#. Tag: para
#: basic_mapping.xml:1745
#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): "
-"by default, single point associations are proxied. <literal>lazy=\"no-proxy"
-"\"</literal> specifies that the property should be fetched lazily when the "
-"instance variable is first accessed. It requires build-time bytecode "
-"instrumentation. <literal>lazy=\"false\"</literal> specifies that the "
-"association will always be eagerly fetched. <emphasis>Note that if "
-"<literal>constrained=\"false\"</literal>, proxying is impossible and "
-"Hibernate will eagerly fetch the association</emphasis>."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况"
-"下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal>指定此属性应该"
-"在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增"
-"强）。 <literal>lazy=\"false\"</literal>指定此关联总是被预先抓取。<emphasis>"
-"注意，如果<literal>constrained=\"false\"</literal>, 不可能使用代理，Hibernate"
-"会采取预先抓取！</emphasis>"
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): by default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation. <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eagerly fetch the association</emphasis>."
+msgstr "<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal>指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增强）。 <literal>lazy=\"false\"</literal>指定此关联总是被预先抓取。<emphasis>注意，如果<literal>constrained=\"false\"</literal>, 不可能使用代理，Hibernate会采取预先抓取！</emphasis>"
#. Tag: para
#: basic_mapping.xml:1763
@@ -3299,25 +2145,14 @@
#. Tag: para
#: basic_mapping.xml:1775
#, fuzzy, no-c-format
-msgid ""
-"Primary key associations do not need an extra table column. If two rows are "
-"related by the association, then the two table rows share the same primary "
-"key value. To relate two objects by a primary key association, ensure that "
-"they are assigned the same identifier value."
-msgstr ""
-"主键关联不需要额外的表字段；如果两行是通过这种一对一关系相关联的，那么这两行"
-"就共享同样的主关键字值。所以如果你希望两个对象通过主键一对一关联，你必须确认"
-"它们被赋予同样的标识值！"
+msgid "Primary key associations do not need an extra table column. If two rows are related by the association, then the two table rows share the same primary key value. To relate two objects by a primary key association, ensure that they are assigned the same identifier value."
+msgstr "主键关联不需要额外的表字段；如果两行是通过这种一对一关系相关联的，那么这两行就共享同样的主关键字值。所以如果你希望两个对象通过主键一对一关联，你必须确认它们被赋予同样的标识值！"
#. Tag: para
#: basic_mapping.xml:1782
#, fuzzy, no-c-format
-msgid ""
-"For a primary key association, add the following mappings to "
-"<literal>Employee</literal> and <literal>Person</literal> respectively:"
-msgstr ""
-"比如说，对下面的 <literal>Employee</literal> 和 <literal>Person</literal> 进"
-"行主键一对一关联:"
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal> respectively:"
+msgstr "比如说，对下面的 <literal>Employee</literal> 和 <literal>Person</literal> 进行主键一对一关联:"
#. Tag: programlisting
#: basic_mapping.xml:1787
@@ -3328,21 +2163,14 @@
#. Tag: programlisting
#: basic_mapping.xml:1788
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true"
-"\"/>]]>"
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>]]>"
msgstr "<one-to-one name=\"employee\" class=\"Employee\" constrained=\"true\"/>"
#. Tag: para
#: basic_mapping.xml:1790
#, fuzzy, no-c-format
-msgid ""
-"Ensure that the primary keys of the related rows in the PERSON and EMPLOYEE "
-"tables are equal. You use a special Hibernate identifier generation strategy "
-"called <literal>foreign</literal>:"
-msgstr ""
-"现在我们必须确保 PERSON 和 EMPLOYEE 中相关的字段是相等的。我们使用一个被成为 "
-"<literal>foreign</literal> 的特殊的 hibernate 标识符生成策略："
+msgid "Ensure that the primary keys of the related rows in the PERSON and EMPLOYEE tables are equal. You use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr "现在我们必须确保 PERSON 和 EMPLOYEE 中相关的字段是相等的。我们使用一个被成为 <literal>foreign</literal> 的特殊的 hibernate 标识符生成策略："
#. Tag: programlisting
#: basic_mapping.xml:1796
@@ -3375,53 +2203,32 @@
#. Tag: para
#: basic_mapping.xml:1798
#, fuzzy, no-c-format
-msgid ""
-"A newly saved instance of <literal>Person</literal> is assigned the same "
-"primary key value as the <literal>Employee</literal> instance referred with "
-"the <literal>employee</literal> property of that <literal>Person</literal>."
-msgstr ""
-"一个刚刚保存的 <literal>Person</literal> 实例被赋予和该 <literal>Person</"
-"literal> 的 <literal>employee</literal> 属性所指向的 <literal>Employee</"
-"literal> 实例同样的关键字值。"
+msgid "A newly saved instance of <literal>Person</literal> is assigned the same primary key value as the <literal>Employee</literal> instance referred with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr "一个刚刚保存的 <literal>Person</literal> 实例被赋予和该 <literal>Person</literal> 的 <literal>employee</literal> 属性所指向的 <literal>Employee</literal> 实例同样的关键字值。"
#. Tag: para
#: basic_mapping.xml:1804
#, fuzzy, no-c-format
-msgid ""
-"Alternatively, a foreign key with a unique constraint, from "
-"<literal>Employee</literal> to <literal>Person</literal>, can be expressed "
-"as:"
-msgstr ""
-"另一种方式是一个外键和一个惟一关键字对应，上面的 <literal>Employee</literal> "
-"和 <literal>Person</literal> 的例子，如果使用这种关联方式，可以表达成："
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, can be expressed as:"
+msgstr "另一种方式是一个外键和一个惟一关键字对应，上面的 <literal>Employee</literal> 和 <literal>Person</literal> 的例子，如果使用这种关联方式，可以表达成："
#. Tag: programlisting
#: basic_mapping.xml:1809
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" "
-"unique=\"true\"/>]]>"
-msgstr ""
-"<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique="
-"\"true\"/>"
+msgid "<![CDATA[<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>]]>"
+msgstr "<many-to-one name=\"person\" class=\"Person\" column=\"PERSON_ID\" unique=\"true\"/>"
#. Tag: para
#: basic_mapping.xml:1811
#, fuzzy, no-c-format
-msgid ""
-"This association can be made bidirectional by adding the following to the "
-"<literal>Person</literal> mapping:"
+msgid "This association can be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
msgstr "如果在 <literal>Person</literal> 的映射加入下面几句，这种关联就是双向的："
#. Tag: programlisting
#: basic_mapping.xml:1816
#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref="
-"\"person\"/>]]>"
-msgstr ""
-"<one-to-one name\"employee\" class=\"Employee\" property-ref=\"person\"/"
-">"
+msgid "<![CDATA[<one-to-one name=\"employee\" class=\"Employee\" property-ref=\"person\"/>]]>"
+msgstr "<one-to-one name\"employee\" class=\"Employee\" property-ref=\"person\"/>"
#. Tag: title
#: basic_mapping.xml:1821
@@ -3448,51 +2255,26 @@
#. Tag: para
#: basic_mapping.xml:1825
#, fuzzy, no-c-format
-msgid ""
-"Although we recommend the use of surrogate keys as primary keys, you should "
-"try to identify natural keys for all entities. A natural key is a property "
-"or combination of properties that is unique and non-null. It is also "
-"immutable. Map the properties of the natural key inside the <literal><"
-"natural-id></literal> element. Hibernate will generate the necessary "
-"unique key and nullability constraints and, as a result, your mapping will "
-"be more self-documenting."
-msgstr ""
-"我们建议使用代用键（键值不具备实际意义）作为主键，我们仍然应该尝试为所有的实"
-"体采用自然的键值作为（附加——译者注）标示。自然键（natural key）是单个或组合属"
-"性，他们必须唯一且非空。如果它还是不可变的那就更理想了。在 <literal><"
-"natural-id></literal> 元素中列出自然键的属性。Hibernate 会帮你生成必须的唯"
-"一键值和非空约束，你的映射会更加的明显易懂（原文是 self-documenting，自我注"
-"解）。"
+msgid "Although we recommend the use of surrogate keys as primary keys, you should try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. It is also immutable. Map the properties of the natural key inside the <literal><natural-id></literal> element. Hibernate will generate the necessary unique key and nullability constraints and, as a result, your mapping will be more self-documenting."
+msgstr "我们建议使用代用键（键值不具备实际意义）作为主键，我们仍然应该尝试为所有的实体采用自然的键值作为（附加——译者注）标示。自然键（natural key）是单个或组合属性，他们必须唯一且非空。如果它还是不可变的那就更理想了。在 <literal><natural-id></literal> 元素中列出自然键的属性。Hibernate 会帮你生成必须的唯一键值和非空约束，你的映射会更加的明显易懂（原文是 self-documenting，自我注解）。"
#. Tag: para
#: basic_mapping.xml:1834
#, fuzzy, no-c-format
-msgid ""
-"It is recommended that you implement <literal>equals()</literal> and "
-"<literal>hashCode()</literal> to compare the natural key properties of the "
-"entity."
-msgstr ""
-"我们强烈建议你实现 <literal>equals()</literal> 和 <literal>hashCode()</"
-"literal> 方法,来比较实体的自然键属性。"
+msgid "It is recommended that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr "我们强烈建议你实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法,来比较实体的自然键属性。"
#. Tag: para
#: basic_mapping.xml:1839
#, fuzzy, no-c-format
-msgid ""
-"This mapping is not intended for use with entities that have natural primary "
-"keys."
+msgid "This mapping is not intended for use with entities that have natural primary keys."
msgstr "这一映射不是为了把自然键作为主键而准备的。"
#. Tag: para
#: basic_mapping.xml:1845
#, fuzzy, no-c-format
-msgid ""
-"<literal>mutable</literal> (optional - defaults to <literal>false</"
-"literal>): by default, natural identifier properties are assumed to be "
-"immutable (constant)."
-msgstr ""
-"<literal>mutable</literal>（可选，默认为 <literal>false</literal>）：默认情况"
-"下，自然标识属性被假定为不可变的（常量）。"
+msgid "<literal>mutable</literal> (optional - defaults to <literal>false</literal>): by default, natural identifier properties are assumed to be immutable (constant)."
+msgstr "<literal>mutable</literal>（可选，默认为 <literal>false</literal>）：默认情况下，自然标识属性被假定为不可变的（常量）。"
#. Tag: title
#: basic_mapping.xml:1855
@@ -3503,15 +2285,8 @@
#. Tag: para
#: basic_mapping.xml:1857
#, fuzzy, no-c-format
-msgid ""
-"The <literal><component></literal> element maps properties of a child "
-"object to columns of the table of a parent class. Components can, in turn, "
-"declare their own properties, components or collections. See the \"Component"
-"\" examples below:"
-msgstr ""
-"<literal><component></literal> 元素把子对象的一些元素与父类对应的表的一"
-"些字段映射起来。然后组件可以定义它们自己的属性、组件或者集合。参见后面"
-"的“Components”一章。"
+msgid "The <literal><component></literal> element maps properties of a child object to columns of the table of a parent class. Components can, in turn, declare their own properties, components or collections. See the \"Component\" examples below:"
+msgstr "<literal><component></literal> 元素把子对象的一些元素与父类对应的表的一些字段映射起来。然后组件可以定义它们自己的属性、组件或者集合。参见后面的“Components”一章。"
#. Tag: programlisting
#: basic_mapping.xml:1875
@@ -3554,101 +2329,59 @@
#. Tag: para
#: basic_mapping.xml:1883
#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal> (optional - defaults to the property type "
-"determined by reflection): the name of the component (child) class."
-msgstr ""
-"<literal>class</literal>（可选 — 默认为通过反射得到的属性类型）：组件（子）类"
-"的名字。"
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the name of the component (child) class."
+msgstr "<literal>class</literal>（可选 — 默认为通过反射得到的属性类型）：组件（子）类的名字。"
#. Tag: para
-#: basic_mapping.xml:1889 basic_mapping.xml:1978
+#: basic_mapping.xml:1889
+#: basic_mapping.xml:1978
#, fuzzy, no-c-format
-msgid ""
-"<literal>insert</literal>: do the mapped columns appear in SQL "
-"<literal>INSERTs</literal>?"
-msgstr ""
-"<literal>insert</literal>：被映射的字段是否出现在 SQL 的 <literal>INSERT</"
-"literal> 语句中？"
+msgid "<literal>insert</literal>: do the mapped columns appear in SQL <literal>INSERTs</literal>?"
+msgstr "<literal>insert</literal>：被映射的字段是否出现在 SQL 的 <literal>INSERT</literal> 语句中？"
#. Tag: para
-#: basic_mapping.xml:1895 basic_mapping.xml:1984
+#: basic_mapping.xml:1895
+#: basic_mapping.xml:1984
#, fuzzy, no-c-format
-msgid ""
-"<literal>update</literal>: do the mapped columns appear in SQL "
-"<literal>UPDATEs</literal>?"
-msgstr ""
-"<literal>update</literal>：被映射的字段是否出现在 SQL 的 <literal>UPDATE</"
-"literal> 语句中？"
+msgid "<literal>update</literal>: do the mapped columns appear in SQL <literal>UPDATEs</literal>?"
+msgstr "<literal>update</literal>：被映射的字段是否出现在 SQL 的 <literal>UPDATE</literal> 语句中？"
#. Tag: para
#: basic_mapping.xml:1907
#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>false</literal>): "
-"specifies that this component should be fetched lazily when the instance "
-"variable is first accessed. It requires build-time bytecode instrumentation."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认是 <literal>false</literal>）：表明此组件"
-"应在实例变量第一次被访问的时候延迟加载（需要编译时字节码装置器）"
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): specifies that this component should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation."
+msgstr "<literal>lazy</literal>（可选 — 默认是 <literal>false</literal>）：表明此组件应在实例变量第一次被访问的时候延迟加载（需要编译时字节码装置器）"
#. Tag: para
#: basic_mapping.xml:1914
#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to this component either do or do not "
-"require acquisition of the optimistic lock. It determines if a version "
-"increment should occur when this property is dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）："
-"表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号"
-"（Version）"
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to this component either do or do not require acquisition of the optimistic lock. It determines if a version increment should occur when this property is dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）：表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号（Version）"
#. Tag: para
-#: basic_mapping.xml:1922 basic_mapping.xml:1998
+#: basic_mapping.xml:1922
+#: basic_mapping.xml:1998
#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional - defaults to <literal>false</literal>): "
-"specifies that a unique constraint exists upon all mapped columns of the "
-"component."
-msgstr ""
-"<literal>unique</literal>（可选 — 默认是 <literal>false</literal>）：表明组件"
-"映射的所有字段上都有唯一性约束"
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr "<literal>unique</literal>（可选 — 默认是 <literal>false</literal>）：表明组件映射的所有字段上都有唯一性约束"
#. Tag: para
#: basic_mapping.xml:1931
#, no-c-format
-msgid ""
-"The child <literal><property></literal> tags map properties of the "
-"child class to table columns."
-msgstr ""
-"其 <literal><property></literal> 子标签为子类的一些属性与表字段之间建立"
-"映射。"
+msgid "The child <literal><property></literal> tags map properties of the child class to table columns."
+msgstr "其 <literal><property></literal> 子标签为子类的一些属性与表字段之间建立映射。"
#. Tag: para
#: basic_mapping.xml:1936
#, no-c-format
-msgid ""
-"The <literal><component></literal> element allows a <literal><"
-"parent></literal> subelement that maps a property of the component class "
-"as a reference back to the containing entity."
-msgstr ""
-"<literal><component></literal> 元素允许加入一个 <literal><parent>"
-"</literal> 子元素，在组件类内部就可以有一个指向其容器的实体的反向引用。"
+msgid "The <literal><component></literal> element allows a <literal><parent></literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "<literal><component></literal> 元素允许加入一个 <literal><parent></literal> 子元素，在组件类内部就可以有一个指向其容器的实体的反向引用。"
#. Tag: para
#: basic_mapping.xml:1942
#, fuzzy, no-c-format
-msgid ""
-"The <literal><dynamic-component></literal> element allows a "
-"<literal>Map</literal> to be mapped as a component, where the property names "
-"refer to keys of the map. See <xref linkend=\"components-dynamic\"/> for "
-"more information."
-msgstr ""
-"<literal><dynamic-component></literal> 元素允许把一个 <literal>Map</"
-"literal> 映射为组件，其属性名对应 map 的键值。参见 <xref linkend="
-"\"Component_Mapping-Dynamic_components\"/>。"
+msgid "The <literal><dynamic-component></literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map. See <xref linkend=\"components-dynamic\"/> for more information."
+msgstr "<literal><dynamic-component></literal> 元素允许把一个 <literal>Map</literal> 映射为组件，其属性名对应 map 的键值。参见 <xref linkend=\"Component_Mapping-Dynamic_components\"/>。"
#. Tag: title
#: basic_mapping.xml:1951
@@ -3659,17 +2392,8 @@
#. Tag: para
#: basic_mapping.xml:1953
#, fuzzy, no-c-format
-msgid ""
-"The <literal><properties></literal> element allows the definition of a "
-"named, logical grouping of the properties of a class. The most important use "
-"of the construct is that it allows a combination of properties to be the "
-"target of a <literal>property-ref</literal>. It is also a convenient way to "
-"define a multi-column unique constraint. For example:"
-msgstr ""
-"<literal><properties></literal> 元素允许定义一个命名的逻辑分组"
-"（grouping）包含一个类中的多个属性。这个元素最重要的用处是允许多个属性的组合"
-"作为 <literal>property-ref</literal> 的目标（target）。这也是定义多字段唯一约"
-"束的一种方便途径。"
+msgid "The <literal><properties></literal> element allows the definition of a named, logical grouping of the properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint. For example:"
+msgstr "<literal><properties></literal> 元素允许定义一个命名的逻辑分组（grouping）包含一个类中的多个属性。这个元素最重要的用处是允许多个属性的组合作为 <literal>property-ref</literal> 的目标（target）。这也是定义多字段唯一约束的一种方便途径。"
#. Tag: programlisting
#: basic_mapping.xml:1969
@@ -3704,32 +2428,19 @@
#. Tag: para
#: basic_mapping.xml:1972
#, fuzzy, no-c-format
-msgid ""
-"<literal>name</literal>: the logical name of the grouping. It is "
-"<emphasis>not</emphasis> an actual property name."
-msgstr ""
-"<literal>name</literal>：分组的逻辑名称 — <emphasis>不是</emphasis> 实际属性"
-"的名称。"
+msgid "<literal>name</literal>: the logical name of the grouping. It is <emphasis>not</emphasis> an actual property name."
+msgstr "<literal>name</literal>：分组的逻辑名称 — <emphasis>不是</emphasis> 实际属性的名称。"
#. Tag: para
#: basic_mapping.xml:1990
#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to these properties either do or do not "
-"require acquisition of the optimistic lock. It determines if a version "
-"increment should occur when these properties are dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）："
-"表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号"
-"（Version）"
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to these properties either do or do not require acquisition of the optimistic lock. It determines if a version increment should occur when these properties are dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）：表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号（Version）"
#. Tag: para
#: basic_mapping.xml:2007
#, no-c-format
-msgid ""
-"For example, if we have the following <literal><properties></literal> "
-"mapping:"
+msgid "For example, if we have the following <literal><properties></literal> mapping:"
msgstr "例如，如果我们有如下的 <literal><properties></literal> 映射："
#. Tag: programlisting
@@ -3762,12 +2473,8 @@
#. Tag: para
#: basic_mapping.xml:2013
#, fuzzy, no-c-format
-msgid ""
-"You might have some legacy data association that refers to this unique key "
-"of the <literal>Person</literal> table, instead of to the primary key:"
-msgstr ""
-"然后，我们可能有一些遗留的数据关联，引用 <literal>Person</literal> 表的这个唯"
-"一键，而不是主键。"
+msgid "You might have some legacy data association that refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr "然后，我们可能有一些遗留的数据关联，引用 <literal>Person</literal> 表的这个唯一键，而不是主键。"
#. Tag: programlisting
#: basic_mapping.xml:2018
@@ -3790,9 +2497,7 @@
#. Tag: para
#: basic_mapping.xml:2020
#, fuzzy, no-c-format
-msgid ""
-"The use of this outside the context of mapping legacy data is not "
-"recommended."
+msgid "The use of this outside the context of mapping legacy data is not recommended."
msgstr "我们并不推荐这样使用，除非在映射遗留数据的情况下。"
#. Tag: title
@@ -3804,13 +2509,8 @@
#. Tag: para
#: basic_mapping.xml:2030
#, fuzzy, no-c-format
-msgid ""
-"Polymorphic persistence requires the declaration of each subclass of the "
-"root persistent class. For the table-per-class-hierarchy mapping strategy, "
-"the <literal><subclass></literal> declaration is used. For example:"
-msgstr ""
-"最后，多态持久化需要为父类的每个子类都进行定义。对于“每一棵类继承树对应一个"
-"表”的策略来说，就需要使用 <literal><subclass></literal> 定义。"
+msgid "Polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal><subclass></literal> declaration is used. For example:"
+msgstr "最后，多态持久化需要为父类的每个子类都进行定义。对于“每一棵类继承树对应一个表”的策略来说，就需要使用 <literal><subclass></literal> 定义。"
#. Tag: programlisting
#: basic_mapping.xml:2043
@@ -3847,7 +2547,9 @@
"</subclass>"
#. Tag: para
-#: basic_mapping.xml:2046 basic_mapping.xml:2104 basic_mapping.xml:2167
+#: basic_mapping.xml:2046
+#: basic_mapping.xml:2104
+#: basic_mapping.xml:2167
#, fuzzy, no-c-format
msgid "<literal>name</literal>: the fully qualified class name of the subclass."
msgstr "<literal>name</literal>：子类的全限定名。"
@@ -3855,54 +2557,33 @@
#. Tag: para
#: basic_mapping.xml:2051
#, fuzzy, no-c-format
-msgid ""
-"<literal>discriminator-value</literal> (optional - defaults to the class "
-"name): a value that distinguishes individual subclasses."
-msgstr ""
-"<literal>discriminator-value（辨别标志）</literal>（可选 — 默认为类名）：一个"
-"用于区分每个独立的子类的值。"
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): a value that distinguishes individual subclasses."
+msgstr "<literal>discriminator-value（辨别标志）</literal>（可选 — 默认为类名）：一个用于区分每个独立的子类的值。"
#. Tag: para
#: basic_mapping.xml:2057
#, fuzzy, no-c-format
-msgid ""
-"<literal>proxy</literal> (optional): specifies a class or interface used for "
-"lazy initializing proxies."
-msgstr ""
-"<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使"
-"用。"
+msgid "<literal>proxy</literal> (optional): specifies a class or interface used for lazy initializing proxies."
+msgstr "<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使用。"
#. Tag: para
#: basic_mapping.xml:2063
#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>true</literal>): "
-"setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
-msgstr ""
-"<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 "
-"<literal>lazy=\"false\"</literal> 禁止使用延迟装载。"
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>): setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 <literal>lazy=\"false\"</literal> 禁止使用延迟装载。"
#. Tag: para
#: basic_mapping.xml:2071
#, fuzzy, no-c-format
-msgid ""
-"Each subclass declares its own persistent properties and subclasses. "
-"<literal><version></literal> and <literal><id></literal> "
-"properties are assumed to be inherited from the root class. Each subclass in "
-"a hierarchy must define a unique <literal>discriminator-value</literal>. If "
-"this is not specified, the fully qualified Java class name is used."
-msgstr ""
-"每个子类都应该定义它自己的持久化属性和子类。<literal><version></"
-"literal> 和 <literal><id></literal> 属性可以从根父类继承下来。在一棵继"
-"承树上的每个子类都必须定义一个唯一的 <literal>discriminator-value</literal>。"
-"如果没有指定，就会使用 Java 类的全限定名。"
+msgid "Each subclass declares its own persistent properties and subclasses. <literal><version></literal> and <literal><id></literal> properties are assumed to be inherited from the root class. Each subclass in a hierarchy must define a unique <literal>discriminator-value</literal>. If this is not specified, the fully qualified Java class name is used."
+msgstr "每个子类都应该定义它自己的持久化属性和子类。<literal><version></literal> 和 <literal><id></literal> 属性可以从根父类继承下来。在一棵继承树上的每个子类都必须定义一个唯一的 <literal>discriminator-value</literal>。如果没有指定，就会使用 Java 类的全限定名。"
#. Tag: para
-#: basic_mapping.xml:2079 basic_mapping.xml:2137 basic_mapping.xml:2195
+#: basic_mapping.xml:2079
+#: basic_mapping.xml:2137
+#: basic_mapping.xml:2195
#, fuzzy, no-c-format
-msgid ""
-"For information about inheritance mappings see <xref linkend=\"inheritance\"/"
-">."
+msgid "For information about inheritance mappings see <xref linkend=\"inheritance\"/>."
msgstr "更多关于继承映射的信息，参考 <xref linkend=\"Inheritance_Mapping\"/>。"
#. Tag: title
@@ -3914,15 +2595,8 @@
#. Tag: para
#: basic_mapping.xml:2088
#, fuzzy, no-c-format
-msgid ""
-"Each subclass can also be mapped to its own table. This is called the table-"
-"per-subclass mapping strategy. An inherited state is retrieved by joining "
-"with the table of the superclass. To do this you use the <literal><joined-"
-"subclass></literal> element. For example:"
-msgstr ""
-"此外，每个子类可能被映射到他自己的表中（每个子类一个表的策略）。被继承的状态"
-"通过和超类的表关联得到。我们使用 <literal><joined-subclass></literal> "
-"元素。"
+msgid "Each subclass can also be mapped to its own table. This is called the table-per-subclass mapping strategy. An inherited state is retrieved by joining with the table of the superclass. To do this you use the <literal><joined-subclass></literal> element. For example:"
+msgstr "此外，每个子类可能被映射到他自己的表中（每个子类一个表的策略）。被继承的状态通过和超类的表关联得到。我们使用 <literal><joined-subclass></literal> 元素。"
#. Tag: programlisting
#: basic_mapping.xml:2101
@@ -3971,43 +2645,31 @@
"</joined-subclass>"
#. Tag: para
-#: basic_mapping.xml:2109 basic_mapping.xml:2172
+#: basic_mapping.xml:2109
+#: basic_mapping.xml:2172
#, fuzzy, no-c-format
msgid "<literal>table</literal>: the name of the subclass table."
msgstr "<literal>table</literal>：子类的表名"
#. Tag: para
-#: basic_mapping.xml:2114 basic_mapping.xml:2177
+#: basic_mapping.xml:2114
+#: basic_mapping.xml:2177
#, fuzzy, no-c-format
-msgid ""
-"<literal>proxy</literal> (optional): specifies a class or interface to use "
-"for lazy initializing proxies."
-msgstr ""
-"<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使"
-"用。"
+msgid "<literal>proxy</literal> (optional): specifies a class or interface to use for lazy initializing proxies."
+msgstr "<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使用。"
#. Tag: para
-#: basic_mapping.xml:2120 basic_mapping.xml:2183
+#: basic_mapping.xml:2120
+#: basic_mapping.xml:2183
#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional, defaults to <literal>true</literal>): "
-"setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
-msgstr ""
-"<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 "
-"<literal>lazy=\"false\"</literal> 禁止使用延迟装载。"
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 <literal>lazy=\"false\"</literal> 禁止使用延迟装载。"
#. Tag: para
#: basic_mapping.xml:2128
#, fuzzy, no-c-format
-msgid ""
-"A discriminator column is not required for this mapping strategy. Each "
-"subclass must, however, declare a table column holding the object identifier "
-"using the <literal><key></literal> element. The mapping at the start "
-"of the chapter would then be re-written as:"
-msgstr ""
-"这种映射策略不需要指定辨别标志（discriminator）字段。但是，每一个子类都必须使"
-"用 <literal><key></literal> 元素指定一个表字段来持有对象的标识符。本章"
-"开始的映射可以被用如下方式重写："
+msgid "A discriminator column is not required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal><key></literal> element. The mapping at the start of the chapter would then be re-written as:"
+msgstr "这种映射策略不需要指定辨别标志（discriminator）字段。但是，每一个子类都必须使用 <literal><key></literal> 元素指定一个表字段来持有对象的标识符。本章开始的映射可以被用如下方式重写："
#. Tag: programlisting
#: basic_mapping.xml:2135
@@ -4033,8 +2695,7 @@
" <key column=\"MOTHER\"/>\n"
" <one-to-many class=\"Cat\"/>\n"
" </set>\n"
-" <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS"
-"\">\n"
+" <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
" <key column=\"CAT\"/>\n"
" <property name=\"name\" type=\"string\"/>\n"
" </joined-subclass>\n"
@@ -4066,8 +2727,7 @@
" <key column=\"MOTHER\"/>\n"
" <one-to-many class=\"Cat\"/>\n"
" </set>\n"
-" <joined-subclass name=\"DomesticCat\" table="
-"\"DOMESTIC_CATS\">\n"
+" <joined-subclass name=\"DomesticCat\" table=\"DOMESTIC_CATS\">\n"
" <key column=\"CAT\"/>\n"
" <property name=\"name\" type=\"string\"/>\n"
" </joined-subclass>\n"
@@ -4088,22 +2748,8 @@
#. Tag: para
#: basic_mapping.xml:2146
#, fuzzy, no-c-format
-msgid ""
-"A third option is to map only the concrete classes of an inheritance "
-"hierarchy to tables. This is called the table-per-concrete-class strategy. "
-"Each table defines all persistent states of the class, including the "
-"inherited state. In Hibernate, it is not necessary to explicitly map such "
-"inheritance hierarchies. You can map each class with a separate <literal><"
-"class></literal> declaration. However, if you wish use polymorphic "
-"associations (e.g. an association to the superclass of your hierarchy), you "
-"need to use the <literal><union-subclass></literal> mapping. For "
-"example:"
-msgstr ""
-"第三种选择是仅仅映射类继承树中具体类部分到表中（每个具体类一张表的策略）。其"
-"中，每张表定义了类的所有持久化状态，包括继承的状态。在 Hibernate 中，并不需要"
-"完全显式地映射这样的继承树。你可以简单地使用单独的 <literal><class></"
-"literal> 定义映射每个类。然而，如果你想使用多态关联（例如，一个对类继承树中超"
-"类的关联），你需要使用 <literal><union-subclass></literal> 映射。"
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables. This is called the table-per-concrete-class strategy. Each table defines all persistent states of the class, including the inherited state. In Hibernate, it is not necessary to explicitly map such inheritance hierarchies. You can map each class with a separate <literal><class></literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal><union-subclass></literal> mapping. For example:"
+msgstr "第三种选择是仅仅映射类继承树中具体类部分到表中（每个具体类一张表的策略）。其中，每张表定义了类的所有持久化状态，包括继承的状态。在 Hibernate 中，并不需要完全显式地映射这样的继承树。你可以简单地使用单独的 <literal><class></literal> 定义映射每个类。然而，如果你想使用多态关联（例如，一个对类继承树中超类的关联），你需要使用 <literal><union-subclass></literal> 映射。"
#. Tag: programlisting
#: basic_mapping.xml:2164
@@ -4164,13 +2810,8 @@
#. Tag: para
#: basic_mapping.xml:2204
#, fuzzy, no-c-format
-msgid ""
-"Using the <literal><join></literal> element, it is possible to map "
-"properties of one class to several tables that have a one-to-one "
-"relationship. For example:"
-msgstr ""
-"使用 <literal><join></literal> 元素，假若在表之间存在一对一关联,可以将"
-"一个类的属性映射到多张表中。"
+msgid "Using the <literal><join></literal> element, it is possible to map properties of one class to several tables that have a one-to-one relationship. For example:"
+msgstr "使用 <literal><join></literal> 元素，假若在表之间存在一对一关联,可以将一个类的属性映射到多张表中。"
#. Tag: programlisting
#: basic_mapping.xml:2218
@@ -4213,58 +2854,26 @@
#. Tag: para
#: basic_mapping.xml:2239
#, fuzzy, no-c-format
-msgid ""
-"<literal>fetch</literal> (optional - defaults to <literal>join</literal>): "
-"if set to <literal>join</literal>, the default, Hibernate will use an inner "
-"join to retrieve a <literal><join></literal> defined by a class or its "
-"superclasses. It will use an outer join for a <literal><join></"
-"literal> defined by a subclass. If set to <literal>select</literal> then "
-"Hibernate will use a sequential select for a <literal><join></literal> "
-"defined on a subclass. This will be issued only if a row represents an "
-"instance of the subclass. Inner joins will still be used to retrieve a "
-"<literal><join></literal> defined by the class and its superclasses."
-msgstr ""
-"<literal>fetch</literal>（可选 — 默认是 <literal>join</literal>）：如果设置为"
-"默认值 <literal>join</literal>，Hibernate 将使用一个内连接来得到这个类或其超"
-"类定义的 <literal><join></literal>，而使用一个外连接来得到其子类定义的 "
-"<literal><join></literal>。如果设置为 <literal>select</literal>，则 "
-"Hibernate 将为子类定义的 <literal><join></literal> 使用顺序选择。这仅在"
-"一行数据表示一个子类的对象的时候才会发生。对这个类和其超类定义的 "
-"<literal><join></literal>，依然会使用内连接得到。"
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): if set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal><join></literal> defined by a class or its superclasses. It will use an outer join for a <literal><join></literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal><join></literal> defined on a subclass. This will be issued only if a row represents an instance of the subclass. Inner joins will still be used to retrieve a <literal><join></literal> defined by the class and its superclasses."
+msgstr "<literal>fetch</literal>（可选 — 默认是 <literal>join</literal>）：如果设置为默认值 <literal>join</literal>，Hibernate 将使用一个内连接来得到这个类或其超类定义的 <literal><join></literal>，而使用一个外连接来得到其子类定义的 <literal><join></literal>。如果设置为 <literal>select</literal>，则 Hibernate 将为子类定义的 <literal><join></literal> 使用顺序选择。这仅在一行数据表示一个子类的对象的时候才会发生。对这个类和其超类定义的 <literal><join></literal>，依然会使用内连接得到。"
#. Tag: para
#: basic_mapping.xml:2252
#, fuzzy, no-c-format
-msgid ""
-"<literal>inverse</literal> (optional - defaults to <literal>false</"
-"literal>): if enabled, Hibernate will not insert or update the properties "
-"defined by this join."
-msgstr ""
-"<literal>inverse</literal>（可选 — 默认是 <literal>false</literal>）：如果打"
-"开，Hibernate 不会插入或者更新此连接定义的属性。"
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): if enabled, Hibernate will not insert or update the properties defined by this join."
+msgstr "<literal>inverse</literal>（可选 — 默认是 <literal>false</literal>）：如果打开，Hibernate 不会插入或者更新此连接定义的属性。"
#. Tag: para
#: basic_mapping.xml:2259
#, fuzzy, no-c-format
-msgid ""
-"<literal>optional</literal> (optional - defaults to <literal>false</"
-"literal>): if enabled, Hibernate will insert a row only if the properties "
-"defined by this join are non-null. It will always use an outer join to "
-"retrieve the properties."
-msgstr ""
-"<literal>optional</literal>（可选 — 默认是 <literal>false</literal>）：如果打"
-"开，Hibernate 只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连"
-"接来得到这些属性。"
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): if enabled, Hibernate will insert a row only if the properties defined by this join are non-null. It will always use an outer join to retrieve the properties."
+msgstr "<literal>optional</literal>（可选 — 默认是 <literal>false</literal>）：如果打开，Hibernate 只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连接来得到这些属性。"
#. Tag: para
#: basic_mapping.xml:2268
#, fuzzy, no-c-format
-msgid ""
-"For example, address information for a person can be mapped to a separate "
-"table while preserving value type semantics for all properties:"
-msgstr ""
-"例如，一个人（person）的地址（address）信息可以被映射到单独的表中（并保留所有"
-"属性的值类型语义）："
+msgid "For example, address information for a person can be mapped to a separate table while preserving value type semantics for all properties:"
+msgstr "例如，一个人（person）的地址（address）信息可以被映射到单独的表中（并保留所有属性的值类型语义）："
#. Tag: programlisting
#: basic_mapping.xml:2273
@@ -4299,14 +2908,8 @@
#. Tag: para
#: basic_mapping.xml:2275
#, fuzzy, no-c-format
-msgid ""
-"This feature is often only useful for legacy data models. We recommend fewer "
-"tables than classes and a fine-grained domain model. However, it is useful "
-"for switching between inheritance mapping strategies in a single hierarchy, "
-"as explained later."
-msgstr ""
-"此特性常常对遗留数据模型有用，我们推荐表个数比类个数少，以及细粒度的领域模"
-"型。然而，在单独的继承树上切换继承映射策略是有用的，后面会解释这点。"
+msgid "This feature is often only useful for legacy data models. We recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr "此特性常常对遗留数据模型有用，我们推荐表个数比类个数少，以及细粒度的领域模型。然而，在单独的继承树上切换继承映射策略是有用的，后面会解释这点。"
#. Tag: title
#: basic_mapping.xml:2285
@@ -4317,15 +2920,8 @@
#. Tag: para
#: basic_mapping.xml:2287
#, fuzzy, no-c-format
-msgid ""
-"The <literal><key></literal> element has featured a few times within "
-"this guide. It appears anywhere the parent mapping element defines a join to "
-"a new table that references the primary key of the original table. It also "
-"defines the foreign key in the joined table:"
-msgstr ""
-"我们目前已经见到过 <literal><key></literal> 元素多次了。这个元素在父映"
-"射元素定义了对新表的连接，并且在被连接表中定义了一个外键引用原表的主键的情况"
-"下经常使用。"
+msgid "The <literal><key></literal> element has featured a few times within this guide. It appears anywhere the parent mapping element defines a join to a new table that references the primary key of the original table. It also defines the foreign key in the joined table:"
+msgstr "我们目前已经见到过 <literal><key></literal> 元素多次了。这个元素在父映射元素定义了对新表的连接，并且在被连接表中定义了一个外键引用原表的主键的情况下经常使用。"
#. Tag: programlisting
#: basic_mapping.xml:2303
@@ -4352,88 +2948,44 @@
#. Tag: para
#: basic_mapping.xml:2314
#, fuzzy, no-c-format
-msgid ""
-"<literal>on-delete</literal> (optional - defaults to <literal>noaction</"
-"literal>): specifies whether the foreign key constraint has database-level "
-"cascade delete enabled."
-msgstr ""
-"<literal>on-delete</literal>（可选，默认是 <literal>noaction</literal>）：表"
-"明外键关联是否打开数据库级别的级联删除。"
+msgid "<literal>on-delete</literal> (optional - defaults to <literal>noaction</literal>): specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr "<literal>on-delete</literal>（可选，默认是 <literal>noaction</literal>）：表明外键关联是否打开数据库级别的级联删除。"
#. Tag: para
#: basic_mapping.xml:2321
#, fuzzy, no-c-format
-msgid ""
-"<literal>property-ref</literal> (optional): specifies that the foreign key "
-"refers to columns that are not the primary key of the original table. It is "
-"provided for legacy data."
-msgstr ""
-"<literal>property-ref</literal>（可选）：表明外键引用的字段不是原表的主键（提"
-"供给遗留数据）。"
+msgid "<literal>property-ref</literal> (optional): specifies that the foreign key refers to columns that are not the primary key of the original table. It is provided for legacy data."
+msgstr "<literal>property-ref</literal>（可选）：表明外键引用的字段不是原表的主键（提供给遗留数据）。"
#. Tag: para
#: basic_mapping.xml:2328
#, fuzzy, no-c-format
-msgid ""
-"<literal>not-null</literal> (optional): specifies that the foreign key "
-"columns are not nullable. This is implied whenever the foreign key is also "
-"part of the primary key."
-msgstr ""
-"<literal>not-null</literal>（可选）：表明外键的字段不可为空（这意味着无论何时"
-"外键都是主键的一部分）。"
+msgid "<literal>not-null</literal> (optional): specifies that the foreign key columns are not nullable. This is implied whenever the foreign key is also part of the primary key."
+msgstr "<literal>not-null</literal>（可选）：表明外键的字段不可为空（这意味着无论何时外键都是主键的一部分）。"
#. Tag: para
#: basic_mapping.xml:2335
#, fuzzy, no-c-format
-msgid ""
-"<literal>update</literal> (optional): specifies that the foreign key should "
-"never be updated. This is implied whenever the foreign key is also part of "
-"the primary key."
-msgstr ""
-"<literal>update</literal>（可选）：表明外键决不应该被更新（这意味着无论何时外"
-"键都是主键的一部分）。"
+msgid "<literal>update</literal> (optional): specifies that the foreign key should never be updated. This is implied whenever the foreign key is also part of the primary key."
+msgstr "<literal>update</literal>（可选）：表明外键决不应该被更新（这意味着无论何时外键都是主键的一部分）。"
#. Tag: para
#: basic_mapping.xml:2342
#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional): specifies that the foreign key should "
-"have a unique constraint. This is implied whenever the foreign key is also "
-"the primary key."
-msgstr ""
-"<literal>unique</literal>（可选）：表明外键应有唯一性约束（这意味着无论何时外"
-"键都是主键的一部分）。"
+msgid "<literal>unique</literal> (optional): specifies that the foreign key should have a unique constraint. This is implied whenever the foreign key is also the primary key."
+msgstr "<literal>unique</literal>（可选）：表明外键应有唯一性约束（这意味着无论何时外键都是主键的一部分）。"
#. Tag: para
#: basic_mapping.xml:2350
#, fuzzy, no-c-format
-msgid ""
-"For systems where delete performance is important, we recommend that all "
-"keys should be defined <literal>on-delete=\"cascade\"</literal>. Hibernate "
-"uses a database-level <literal>ON CASCADE DELETE</literal> constraint, "
-"instead of many individual <literal>DELETE</literal> statements. Be aware "
-"that this feature bypasses Hibernate's usual optimistic locking strategy for "
-"versioned data."
-msgstr ""
-"对那些看重删除性能的系统，我们推荐所有的键都应该定义为 <literal>on-delete="
-"\"cascade\"</literal>，这样 Hibernate 将使用数据库级的 <literal>ON CASCADE "
-"DELETE</literal> 约束，而不是多个 <literal>DELETE</literal> 语句。注意，这个"
-"特性会绕过 Hibernate 通常对版本数据（versioned data）采用的乐观锁策略。"
+msgid "For systems where delete performance is important, we recommend that all keys should be defined <literal>on-delete=\"cascade\"</literal>. Hibernate uses a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr "对那些看重删除性能的系统，我们推荐所有的键都应该定义为 <literal>on-delete=\"cascade\"</literal>，这样 Hibernate 将使用数据库级的 <literal>ON CASCADE DELETE</literal> 约束，而不是多个 <literal>DELETE</literal> 语句。注意，这个特性会绕过 Hibernate 通常对版本数据（versioned data）采用的乐观锁策略。"
#. Tag: para
#: basic_mapping.xml:2358
#, fuzzy, no-c-format
-msgid ""
-"The <literal>not-null</literal> and <literal>update</literal> attributes are "
-"useful when mapping a unidirectional one-to-many association. If you map a "
-"unidirectional one-to-many association to a non-nullable foreign key, you "
-"<emphasis>must</emphasis> declare the key column using <literal><key not-"
-"null=\"true\"></literal>."
-msgstr ""
-"<literal>not-null</literal> 和 <literal>update</literal> 属性在映射单向一对多"
-"关联的时候有用。如果你映射一个单向一对多关联到非空的（non-nullable）外键，你"
-"<emphasis>必须</emphasis> 用 <literal><key not-null=\"true\"></"
-"literal> 定义此键字段。"
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one-to-many association. If you map a unidirectional one-to-many association to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal><key not-null=\"true\"></literal>."
+msgstr "<literal>not-null</literal> 和 <literal>update</literal> 属性在映射单向一对多关联的时候有用。如果你映射一个单向一对多关联到非空的（non-nullable）外键，你<emphasis>必须</emphasis> 用 <literal><key not-null=\"true\"></literal> 定义此键字段。"
#. Tag: title
#: basic_mapping.xml:2368
@@ -4444,15 +2996,8 @@
#. Tag: para
#: basic_mapping.xml:2369
#, fuzzy, no-c-format
-msgid ""
-"Mapping elements which accept a <literal>column</literal> attribute will "
-"alternatively accept a <literal><column></literal> subelement. "
-"Likewise, <literal><formula></literal> is an alternative to the "
-"<literal>formula</literal> attribute. For example:"
-msgstr ""
-"任何接受 <literal>column</literal> 属性的映射元素都可以选择接受 <literal><"
-"column></literal> 子元素。同样的，<literal>formula</literal> 子元素也可以"
-"替换 <literal><formula></literal> 属性。"
+msgid "Mapping elements which accept a <literal>column</literal> attribute will alternatively accept a <literal><column></literal> subelement. Likewise, <literal><formula></literal> is an alternative to the <literal>formula</literal> attribute. For example:"
+msgstr "任何接受 <literal>column</literal> 属性的映射元素都可以选择接受 <literal><column></literal> 子元素。同样的，<literal>formula</literal> 子元素也可以替换 <literal><formula></literal> 属性。"
#. Tag: programlisting
#: basic_mapping.xml:2375
@@ -4493,13 +3038,8 @@
#. Tag: para
#: basic_mapping.xml:2379
#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> and <literal>formula</literal> attributes can even "
-"be combined within the same property or association mapping to express, for "
-"example, exotic join conditions."
-msgstr ""
-"<literal>column</literal> 和 <literal>formula</literal> 属性甚至可以在同一个"
-"属性或关联映射中被合并来表达，例如，一些奇异的连接条件。"
+msgid "<literal>column</literal> and <literal>formula</literal> attributes can even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr "<literal>column</literal> 和 <literal>formula</literal> 属性甚至可以在同一个属性或关联映射中被合并来表达，例如，一些奇异的连接条件。"
#. Tag: programlisting
#: basic_mapping.xml:2385
@@ -4526,16 +3066,8 @@
#. Tag: para
#: basic_mapping.xml:2392
#, fuzzy, no-c-format
-msgid ""
-"If your application has two persistent classes with the same name, and you "
-"do not want to specify the fully qualified package name in Hibernate "
-"queries, classes can be \"imported\" explicitly, rather than relying upon "
-"<literal>auto-import=\"true\"</literal>. You can also import classes and "
-"interfaces that are not explicitly mapped:"
-msgstr ""
-"假设你的应用程序有两个同样名字的持久化类，但是你不想在 Hibernate 查询中使用他"
-"们的全限定名。除了依赖 <literal>auto-import=\"true\"</literal> 以外，类也可以"
-"被显式地“import（引用）”。你甚至可以引用没有被明确映射的类和接口。"
+msgid "If your application has two persistent classes with the same name, and you do not want to specify the fully qualified package name in Hibernate queries, classes can be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You can also import classes and interfaces that are not explicitly mapped:"
+msgstr "假设你的应用程序有两个同样名字的持久化类，但是你不想在 Hibernate 查询中使用他们的全限定名。除了依赖 <literal>auto-import=\"true\"</literal> 以外，类也可以被显式地“import（引用）”。你甚至可以引用没有被明确映射的类和接口。"
#. Tag: programlisting
#: basic_mapping.xml:2399
@@ -4566,12 +3098,8 @@
#. Tag: para
#: basic_mapping.xml:2414
#, fuzzy, no-c-format
-msgid ""
-"<literal>rename</literal> (optional - defaults to the unqualified class "
-"name): a name that can be used in the query language."
-msgstr ""
-"<literal>rename</literal>（可选 — 默认为类的全限定名）：在查询语句中可以使用"
-"的名字。"
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): a name that can be used in the query language."
+msgstr "<literal>rename</literal>（可选 — 默认为类的全限定名）：在查询语句中可以使用的名字。"
#. Tag: title
#: basic_mapping.xml:2425
@@ -4582,35 +3110,14 @@
#. Tag: para
#: basic_mapping.xml:2427
#, fuzzy, no-c-format
-msgid ""
-"There is one more type of property mapping. The <literal><any></"
-"literal> mapping element defines a polymorphic association to classes from "
-"multiple tables. This type of mapping requires more than one column. The "
-"first column contains the type of the associated entity. The remaining "
-"columns contain the identifier. It is impossible to specify a foreign key "
-"constraint for this kind of association. This is not the usual way of "
-"mapping polymorphic associations and you should use this only in special "
-"cases. For example, for audit logs, user session data, etc."
-msgstr ""
-"这是属性映射的又一种类型。<literal><any></literal> 映射元素定义了一种从"
-"多个表到类的多态关联。这种类型的映射常常需要多于一个字段。第一个字段持有被关"
-"联实体的类型，其他的字段持有标识符。对这种类型的关联来说，不可能指定一个外键"
-"约束，所以这当然不是映射（多态）关联的通常的方式。你只应该在非常特殊的情况下"
-"使用它(比如，审计 log，用户会话数据等等)。"
+msgid "There is one more type of property mapping. The <literal><any></literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping requires more than one column. The first column contains the type of the associated entity. The remaining columns contain the identifier. It is impossible to specify a foreign key constraint for this kind of association. This is not the usual way of mapping polymorphic associations and you should use this only in special cases. For example, for audit logs, user session data, etc."
+msgstr "这是属性映射的又一种类型。<literal><any></literal> 映射元素定义了一种从多个表到类的多态关联。这种类型的映射常常需要多于一个字段。第一个字段持有被关联实体的类型，其他的字段持有标识符。对这种类型的关联来说，不可能指定一个外键约束，所以这当然不是映射（多态）关联的通常的方式。你只应该在非常特殊的情况下使用它(比如，审计 log，用户会话数据等等)。"
#. Tag: para
#: basic_mapping.xml:2437
#, fuzzy, no-c-format
-msgid ""
-"The <literal>meta-type</literal> attribute allows the application to specify "
-"a custom type that maps database column values to persistent classes that "
-"have identifier properties of the type specified by <literal>id-type</"
-"literal>. You must specify the mapping from values of the meta-type to class "
-"names."
-msgstr ""
-"<literal>meta-type</literal> 属性使得应用程序能指定一个将数据库字段的值映射到"
-"持久化类的自定义类型。这个持久化类包含有用 <literal>id-type</literal> 指定的"
-"标识符属性。你必须指定从 meta-type 的值到类名的映射。"
+msgid "The <literal>meta-type</literal> attribute allows the application to specify a custom type that maps database column values to persistent classes that have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr "<literal>meta-type</literal> 属性使得应用程序能指定一个将数据库字段的值映射到持久化类的自定义类型。这个持久化类包含有用 <literal>id-type</literal> 指定的标识符属性。你必须指定从 meta-type 的值到类名的映射。"
#. Tag: programlisting
#: basic_mapping.xml:2444
@@ -4683,35 +3190,20 @@
#. Tag: para
#: basic_mapping.xml:2468
#, fuzzy, no-c-format
-msgid ""
-"<literal>meta-type</literal> (optional - defaults to <literal>string</"
-"literal>): any type that is allowed for a discriminator mapping."
-msgstr ""
-"<literal>meta-type</literal>（可选 -默认是 <literal>string</literal>）：允许"
-"辨别标志(discriminator)映射的任何类型。"
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): any type that is allowed for a discriminator mapping."
+msgstr "<literal>meta-type</literal>（可选 -默认是 <literal>string</literal>）：允许辨别标志(discriminator)映射的任何类型。"
#. Tag: para
#: basic_mapping.xml:2474
#, no-c-format
-msgid ""
-"<literal>cascade</literal> (optional- defaults to <literal>none</literal>): "
-"the cascade style."
-msgstr ""
-"<literal>cascade</literal>（可选 — 默认是<literal>none</literal>）：级联的类"
-"型。"
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr "<literal>cascade</literal>（可选 — 默认是<literal>none</literal>）：级联的类型。"
#. Tag: para
#: basic_mapping.xml:2486
#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to this property either do or do not "
-"require acquisition of the optimistic lock. It defines whether a version "
-"increment should occur if this property is dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）："
-"表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号"
-"（Version）"
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to this property either do or do not require acquisition of the optimistic lock. It defines whether a version increment should occur if this property is dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）：表明更新此组件是否需要获取乐观锁。换句话说，当这个属性变脏时，是否增加版本号（Version）"
#. Tag: title
#: basic_mapping.xml:2501
@@ -4728,75 +3220,26 @@
#. Tag: para
#: basic_mapping.xml:2506
#, no-c-format
-msgid ""
-"In relation to the persistence service, Java language-level objects are "
-"classified into two groups:"
-msgstr ""
+msgid "In relation to the persistence service, Java language-level objects are classified into two groups:"
+msgstr "和持久化服务相比，Java 级别的对象分为两个组别："
#. Tag: para
#: basic_mapping.xml:2511
#, fuzzy, no-c-format
-msgid ""
-"An <emphasis>entity</emphasis> exists independently of any other objects "
-"holding references to the entity. Contrast this with the usual Java model, "
-"where an unreferenced object is garbage collected. Entities must be "
-"explicitly saved and deleted. Saves and deletions, however, can be "
-"<emphasis>cascaded</emphasis> from a parent entity to its children. This is "
-"different from the ODMG model of object persistence by reachability and "
-"corresponds more closely to how application objects are usually used in "
-"large systems. Entities support circular and shared references. They can "
-"also be versioned."
-msgstr ""
-"<emphasis>实体entity</emphasis> 独立于任何持有实体引用的对象。与通常的 Java "
-"模型相比，不再被引用的对象会被当作垃圾收集掉。实体必须被显式的保存和删除（除"
-"非保存和删除是从父实体向子实体引发的<emphasis>级联</emphasis>）。这和 ODMG 模"
-"型中关于对象通过可触及保持持久性有一些不同 — 比较起来更加接近应用程序对象通常"
-"在一个大系统中的使用方法。实体支持循环引用和交叉引用，它们也可以加上版本信"
-"息。"
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model, where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted. Saves and deletions, however, can be <emphasis>cascaded</emphasis> from a parent entity to its children. This is different from the ODMG model of object persistence by reachability and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They can also be versioned."
+msgstr "<emphasis>实体entity</emphasis> 独立于任何持有实体引用的对象。与通常的 Java 模型相比，不再被引用的对象会被当作垃圾收集掉。实体必须被显式的保存和删除（除非保存和删除是从父实体向子实体引发的<emphasis>级联</emphasis>）。这和 ODMG 模型中关于对象通过可触及保持持久性有一些不同 — 比较起来更加接近应用程序对象通常在一个大系统中的使用方法。实体支持循环引用和交叉引用，它们也可以加上版本信息。"
#. Tag: para
#: basic_mapping.xml:2522
#, fuzzy, no-c-format
-msgid ""
-"An entity's persistent state consists of references to other entities and "
-"instances of <emphasis>value</emphasis> types. Values are primitives: "
-"collections (not what is inside a collection), components and certain "
-"immutable objects. Unlike entities, values in particular collections and "
-"components, <emphasis>are</emphasis> persisted and deleted by reachability. "
-"Since value objects and primitives are persisted and deleted along with "
-"their containing entity, they cannot be independently versioned. Values have "
-"no independent identity, so they cannot be shared by two entities or "
-"collections."
-msgstr ""
-"一个实体的持久状态包含指向其他实体和<emphasis>值</emphasis>类型实例的引用。值"
-"可以是原始类型，集合（不是集合中的对象），组件或者特定的不可变对象。与实体不"
-"同，值（特别是集合和组件）是通过可触及性来进行持久化和删除的。因为值对象（和"
-"原始类型数据）是随着包含他们的实体而被持久化和删除的，他们不能被独立的加上版"
-"本信息。值没有独立的标识，所以他们不能被两个实体或者集合共享。"
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives: collections (not what is inside a collection), components and certain immutable objects. Unlike entities, values in particular collections and components, <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects and primitives are persisted and deleted along with their containing entity, they cannot be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr "一个实体的持久状态包含指向其他实体和<emphasis>值</emphasis>类型实例的引用。值可以是原始类型，集合（不是集合中的对象），组件或者特定的不可变对象。与实体不同，值（特别是集合和组件）是通过可触及性来进行持久化和删除的。因为值对象（和原始类型数据）是随着包含他们的实体而被持久化和删除的，他们不能被独立的加上版本信息。值没有独立的标识，所以他们不能被两个实体或者集合共享。"
#. Tag: para
#: basic_mapping.xml:2533
#, fuzzy, no-c-format
-msgid ""
-"Until now, we have been using the term \"persistent class\" to refer to "
-"entities. We will continue to do that. Not all user-defined classes with a "
-"persistent state, however, are entities. A <emphasis>component</emphasis> is "
-"a user-defined class with value semantics. A Java property of type "
-"<literal>java.lang.String</literal> also has value semantics. Given this "
-"definition, all types (classes) provided by the JDK have value type "
-"semantics in Java, while user-defined types can be mapped with entity or "
-"value type semantics. This decision is up to the application developer. An "
-"entity class in a domain model will normally have shared references to a "
-"single instance of that class, while composition or aggregation usually "
-"translates to a value type."
-msgstr ""
-"直到现在，我们都一直使用术语“持久类”（persistent class）来代表实体。我们仍然"
-"会这么做。然而严格说来，不是所有的用户自定义的，带有持久化状态的类都是实体。"
-"<emphasis>组件</emphasis>就是用户自定义类，却是值语义的。<literal>java.lang."
-"String</literal> 类型的 java 属性也是值语义的。给了这个定义以后，我们可以说所"
-"有 JDK 提供的类型（类）都是值类型的语义，而用于自定义类型可能被映射为实体类型"
-"或值类型语义。采用哪种类型的语义取决于开发人员。在领域模型中，寻找实体类的一"
-"个好线索是共享引用指向这个类的单一实例，而组合或聚合通常被转化为值类型。"
+msgid "Until now, we have been using the term \"persistent class\" to refer to entities. We will continue to do that. Not all user-defined classes with a persistent state, however, are entities. A <emphasis>component</emphasis> is a user-defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, all types (classes) provided by the JDK have value type semantics in Java, while user-defined types can be mapped with entity or value type semantics. This decision is up to the application developer. An entity class in a domain model will normally have shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr "直到现在，我们都一直使用术语“持久类”（persistent class）来代表实体。我们仍然会这么做。然而严格说来，不是所有的用户自定义的，带有持久化状态的类都是实体。<emphasis>组件</emphasis>就是用户自定义类，却是值语义的。<literal>java.lang.String</literal> 类型的 java 属性也是值语义的。给了这个定义以后，我们可以说所有 JDK 提供的类型（类）都是值类型的语义，而用于自定义类型可能被映射为实体类型或值类型语义。采用哪种类型的语义取决于开发人员。在领域模型中，寻找实体类的一个好线索是共享引用指向这个类的单一实例，而组合或聚合通常被转化为值类型。"
#. Tag: para
#: basic_mapping.xml:2547
@@ -4807,33 +3250,13 @@
#. Tag: para
#: basic_mapping.xml:2551
#, fuzzy, no-c-format
-msgid ""
-"The challenge is to map the Java type system, and the developers' definition "
-"of entities and value types, to the SQL/database type system. The bridge "
-"between both systems is provided by Hibernate. For entities, <literal><"
-"class></literal>, <literal><subclass></literal> and so on are used. "
-"For value types we use <literal><property></literal>, <literal><"
-"component></literal>etc., that usually have a <literal>type</literal> "
-"attribute. The value of this attribute is the name of a Hibernate "
-"<emphasis>mapping type</emphasis>. Hibernate provides a range of mappings "
-"for standard JDK value types out of the box. You can write your own mapping "
-"types and implement your own custom conversion strategies."
-msgstr ""
-"挑战在于将 java 类型系统(和开发者定义的实体和值类型)映射到 SQL/数据库类型系"
-"统。Hibernate 提供了连接两个系统之间的桥梁：对于实体类型，我们使用 "
-"<literal><class></literal>，<literal><subclass></literal> 等等。"
-"对于值类型，我们使用 <literal><property></literal>，<literal><"
-"component></literal> 及其他，通常跟随着 <literal>type</literal> 属性。这个"
-"属性的值是Hibernate 的<emphasis>映射类型</emphasis>的名字。Hibernate 提供了许"
-"多现成的映射（标准的 JDK 值类型）。你也可以编写自己的映射类型并实现自定义的变"
-"换策略，随后我们会看到这点。"
+msgid "The challenge is to map the Java type system, and the developers' definition of entities and value types, to the SQL/database type system. The bridge between both systems is provided by Hibernate. For entities, <literal><class></literal>, <literal><subclass></literal> and so on are used. For value types we use <literal><property></literal>, <literal><component></literal>etc., that usually have a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides a range of mappings for standard JDK value types out of the box. You can write your own mapping types and implement your own custom conversion strategies."
+msgstr "挑战在于将 java 类型系统(和开发者定义的实体和值类型)映射到 SQL/数据库类型系统。Hibernate 提供了连接两个系统之间的桥梁：对于实体类型，我们使用 <literal><class></literal>，<literal><subclass></literal> 等等。对于值类型，我们使用 <literal><property></literal>，<literal><component></literal> 及其他，通常跟随着 <literal>type</literal> 属性。这个属性的值是Hibernate 的<emphasis>映射类型</emphasis>的名字。Hibernate 提供了许多现成的映射（标准的 JDK 值类型）。你也可以编写自己的映射类型并实现自定义的变换策略，随后我们会看到这点。"
#. Tag: para
#: basic_mapping.xml:2564
#, fuzzy, no-c-format
-msgid ""
-"With the exception of collections, all built-in Hibernate types support null "
-"semantics."
+msgid "With the exception of collections, all built-in Hibernate types support null semantics."
msgstr "所有的 Hibernate 内建类型，除了 collections 以外，都支持空（null）语义。"
#. Tag: title
@@ -4845,36 +3268,20 @@
#. Tag: para
#: basic_mapping.xml:2573
#, fuzzy, no-c-format
-msgid ""
-"The built-in <emphasis>basic mapping types</emphasis> can be roughly "
-"categorized into the following:"
-msgstr ""
-"内置的 <emphasis>basic mapping types</emphasis> 可以大致地分类至categorized "
-"into"
+msgid "The built-in <emphasis>basic mapping types</emphasis> can be roughly categorized into the following:"
+msgstr "内置的 <emphasis>basic mapping types</emphasis> 可以大致地分类至categorized into"
#. Tag: literal
#: basic_mapping.xml:2578
#, no-c-format
-msgid ""
-"integer, long, short, float, double, character, byte, boolean, yes_no, "
-"true_false"
-msgstr ""
-"integer, long, short, float, double, character, byte, boolean, yes_no, "
-"true_false"
+msgid "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
+msgstr "integer, long, short, float, double, character, byte, boolean, yes_no, true_false"
#. Tag: para
#: basic_mapping.xml:2581
#, no-c-format
-msgid ""
-"Type mappings from Java primitives or wrapper classes to appropriate (vendor-"
-"specific) SQL column types. <literal>boolean, yes_no</literal> and "
-"<literal>true_false</literal> are all alternative encodings for a Java "
-"<literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
-msgstr ""
-"这些类型都对应 Java 的原始类型或者其封装类，来符合（特定厂商的）SQL 字段类"
-"型。<literal>boolean, yes_no</literal> 和 <literal>true_false</literal> 都是 "
-"Java 中 <literal>boolean</literal> 或者 <literal>java.lang.Boolean</literal> "
-"的另外说法。"
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr "这些类型都对应 Java 的原始类型或者其封装类，来符合（特定厂商的）SQL 字段类型。<literal>boolean, yes_no</literal> 和 <literal>true_false</literal> 都是 Java 中 <literal>boolean</literal> 或者 <literal>java.lang.Boolean</literal> 的另外说法。"
#. Tag: literal
#: basic_mapping.xml:2590
@@ -4885,12 +3292,8 @@
#. Tag: para
#: basic_mapping.xml:2592
#, no-c-format
-msgid ""
-"A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</"
-"literal> (or Oracle <literal>VARCHAR2</literal>)."
-msgstr ""
-"从 <literal>java.lang.String</literal> 到 <literal>VARCHAR</literal>（或者 "
-"Oracle 的 <literal>VARCHAR2</literal>）的映射。"
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr "从 <literal>java.lang.String</literal> 到 <literal>VARCHAR</literal>（或者 Oracle 的 <literal>VARCHAR2</literal>）的映射。"
#. Tag: literal
#: basic_mapping.xml:2599
@@ -4901,14 +3304,8 @@
#. Tag: para
#: basic_mapping.xml:2601
#, no-c-format
-msgid ""
-"Type mappings from <literal>java.util.Date</literal> and its subclasses to "
-"SQL types <literal>DATE</literal>, <literal>TIME</literal> and "
-"<literal>TIMESTAMP</literal> (or equivalent)."
-msgstr ""
-"从 <literal>java.util.Date</literal> 和其子类到 SQL 类型 <literal>DATE</"
-"literal>，<literal>TIME</literal> 和 <literal>TIMESTAMP</literal>（或等价类"
-"型）的映射。"
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr "从 <literal>java.util.Date</literal> 和其子类到 SQL 类型 <literal>DATE</literal>，<literal>TIME</literal> 和 <literal>TIMESTAMP</literal>（或等价类型）的映射。"
#. Tag: literal
#: basic_mapping.xml:2609
@@ -4919,12 +3316,8 @@
#. Tag: para
#: basic_mapping.xml:2611
#, no-c-format
-msgid ""
-"Type mappings from <literal>java.util.Calendar</literal> to SQL types "
-"<literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
-msgstr ""
-"从 <literal>java.util.Calendar</literal> 到 SQL 类型 <literal>TIMESTAMP</"
-"literal> 和 <literal>DATE</literal>（或等价类型）的映射。"
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr "从 <literal>java.util.Calendar</literal> 到 SQL 类型 <literal>TIMESTAMP</literal> 和 <literal>DATE</literal>（或等价类型）的映射。"
#. Tag: literal
#: basic_mapping.xml:2619
@@ -4935,14 +3328,8 @@
#. Tag: para
#: basic_mapping.xml:2621
#, no-c-format
-msgid ""
-"Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java."
-"math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle "
-"<literal>NUMBER</literal>)."
-msgstr ""
-"从 <literal>java.math.BigDecimal</literal> 和 <literal>java.math.BigInteger</"
-"literal> 到 <literal>NUMERIC</literal>（或者 Oracle 的 <literal>NUMBER</"
-"literal>类型）的映射。"
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr "从 <literal>java.math.BigDecimal</literal> 和 <literal>java.math.BigInteger</literal> 到 <literal>NUMERIC</literal>（或者 Oracle 的 <literal>NUMBER</literal>类型）的映射。"
#. Tag: literal
#: basic_mapping.xml:2629
@@ -4953,20 +3340,8 @@
#. Tag: para
#: basic_mapping.xml:2631
#, no-c-format
-msgid ""
-"Type mappings from <literal>java.util.Locale</literal>, <literal>java.util."
-"TimeZone</literal> and <literal>java.util.Currency</literal> to "
-"<literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). "
-"Instances of <literal>Locale</literal> and <literal>Currency</literal> are "
-"mapped to their ISO codes. Instances of <literal>TimeZone</literal> are "
-"mapped to their <literal>ID</literal>."
-msgstr ""
-"从 <literal>java.util.Locale</literal>，<literal>java.util.TimeZone</"
-"literal> 和 <literal>java.util.Currency</literal> 到 <literal>VARCHAR</"
-"literal>（或者 Oracle 的 <literal>VARCHAR2</literal> 类型）的映射。"
-"<literal>Locale</literal> 和 <literal>Currency</literal> 的实例被映射为它们"
-"的 ISO 代码。<literal>TimeZone</literal> 的实例被影射为它的 <literal>ID</"
-"literal>。"
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr "从 <literal>java.util.Locale</literal>，<literal>java.util.TimeZone</literal> 和 <literal>java.util.Currency</literal> 到 <literal>VARCHAR</literal>（或者 Oracle 的 <literal>VARCHAR2</literal> 类型）的映射。<literal>Locale</literal> 和 <literal>Currency</literal> 的实例被映射为它们的 ISO 代码。<literal>TimeZone</literal> 的实例被影射为它的 <literal>ID</literal>。"
#. Tag: literal
#: basic_mapping.xml:2643
@@ -4977,14 +3352,8 @@
#. Tag: para
#: basic_mapping.xml:2645
#, no-c-format
-msgid ""
-"A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</"
-"literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> "
-"is mapped to its fully qualified name."
-msgstr ""
-"从 <literal>java.lang.Class</literal> 到 <literal>VARCHAR</literal>（或者 "
-"Oracle 的 <literal>VARCHAR2</literal> 类型）的映射。<literal>Class</literal> "
-"被映射为它的全限定名。"
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr "从 <literal>java.lang.Class</literal> 到 <literal>VARCHAR</literal>（或者 Oracle 的 <literal>VARCHAR2</literal> 类型）的映射。<literal>Class</literal> 被映射为它的全限定名。"
#. Tag: literal
#: basic_mapping.xml:2653
@@ -5007,12 +3376,8 @@
#. Tag: para
#: basic_mapping.xml:2663
#, no-c-format
-msgid ""
-"Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</"
-"literal> type."
-msgstr ""
-"把长 Java 字符串映射为 SQL 的 <literal>CLOB</literal> 或者 <literal>TEXT</"
-"literal> 类型。"
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr "把长 Java 字符串映射为 SQL 的 <literal>CLOB</literal> 或者 <literal>TEXT</literal> 类型。"
#. Tag: literal
#: basic_mapping.xml:2670
@@ -5023,14 +3388,8 @@
#. Tag: para
#: basic_mapping.xml:2672
#, fuzzy, no-c-format
-msgid ""
-"Maps serializable Java types to an appropriate SQL binary type. You can also "
-"indicate the Hibernate type <literal>serializable</literal> with the name of "
-"a serializable Java class or interface that does not default to a basic type."
-msgstr ""
-"把可序列化的 Java 类型映射到对应的 SQL 二进制类型。你也可以为一个并非默认为基"
-"本类型的可序列化 Java 类或者接口指定 Hibernate 类型 <literal>serializable</"
-"literal>。"
+msgid "Maps serializable Java types to an appropriate SQL binary type. You can also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr "把可序列化的 Java 类型映射到对应的 SQL 二进制类型。你也可以为一个并非默认为基本类型的可序列化 Java 类或者接口指定 Hibernate 类型 <literal>serializable</literal>。"
#. Tag: literal
#: basic_mapping.xml:2681
@@ -5041,69 +3400,32 @@
#. Tag: para
#: basic_mapping.xml:2683
#, fuzzy, no-c-format
-msgid ""
-"Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and "
-"<literal>java.sql.Blob</literal>. These types can be inconvenient for some "
-"applications, since the blob or clob object cannot be reused outside of a "
-"transaction. Driver support is patchy and inconsistent."
-msgstr ""
-"JDBC 类 <literal>java.sql.Clob</literal> 和 <literal>java.sql.Blob</literal>"
-"的映射。某些程序可能不适合使用这个类型，因为 blob 和 clob 对象可能在一个事务"
-"之外是无法重用的。（而且, 驱动程序对这种类型的支持充满着补丁和前后矛盾。）"
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types can be inconvenient for some applications, since the blob or clob object cannot be reused outside of a transaction. Driver support is patchy and inconsistent."
+msgstr "JDBC 类 <literal>java.sql.Clob</literal> 和 <literal>java.sql.Blob</literal>的映射。某些程序可能不适合使用这个类型，因为 blob 和 clob 对象可能在一个事务之外是无法重用的。（而且, 驱动程序对这种类型的支持充满着补丁和前后矛盾。）"
#. Tag: literal
#: basic_mapping.xml:2693
#, no-c-format
-msgid ""
-"imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, "
-"imm_serializable, imm_binary"
-msgstr ""
-"imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, "
-"imm_serializable, imm_binary"
+msgid "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
+msgstr "imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary"
#. Tag: para
#: basic_mapping.xml:2697
#, fuzzy, no-c-format
-msgid ""
-"Type mappings for what are considered mutable Java types. This is where "
-"Hibernate makes certain optimizations appropriate only for immutable Java "
-"types, and the application treats the object as immutable. For example, you "
-"should not call <literal>Date.setTime()</literal> for an instance mapped as "
-"<literal>imm_timestamp</literal>. To change the value of the property, and "
-"have that change made persistent, the application must assign a new, "
-"nonidentical, object to the property."
-msgstr ""
-"一般来说，映射类型被假定为是可变的 Java 类型，只有对不可变 Java 类型，"
-"Hibernate 会采取特定的优化措施，应用程序会把这些对象作为不可变对象处理。比"
-"如，你不应该对作为 <literal>imm_timestamp</literal> 映射的 Date 执行 "
-"<literal>Date.setTime()</literal>。要改变属性的值，并且保存这一改变，应用程序"
-"必须对这一属性重新设置一个新的（不一样的）对象。"
+msgid "Type mappings for what are considered mutable Java types. This is where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new, nonidentical, object to the property."
+msgstr "一般来说，映射类型被假定为是可变的 Java 类型，只有对不可变 Java 类型，Hibernate 会采取特定的优化措施，应用程序会把这些对象作为不可变对象处理。比如，你不应该对作为 <literal>imm_timestamp</literal> 映射的 Date 执行 <literal>Date.setTime()</literal>。要改变属性的值，并且保存这一改变，应用程序必须对这一属性重新设置一个新的（不一样的）对象。"
#. Tag: para
#: basic_mapping.xml:2712
#, fuzzy, no-c-format
-msgid ""
-"Unique identifiers of entities and collections can be of any basic type "
-"except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</"
-"literal>. Composite identifiers are also allowed. See below for more "
-"information."
-msgstr ""
-"实体及其集合的唯一标识可以是除了 <literal>binary</literal>、 <literal>blob</"
-"literal> 和 <literal>clob</literal> 之外的任何基础类型。（联合标识也是允许"
-"的，后面会说到。）"
+msgid "Unique identifiers of entities and collections can be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. Composite identifiers are also allowed. See below for more information."
+msgstr "实体及其集合的唯一标识可以是除了 <literal>binary</literal>、 <literal>blob</literal> 和 <literal>clob</literal> 之外的任何基础类型。（联合标识也是允许的，后面会说到。）"
#. Tag: para
#: basic_mapping.xml:2718
#, no-c-format
-msgid ""
-"The basic value types have corresponding <literal>Type</literal> constants "
-"defined on <literal>org.hibernate.Hibernate</literal>. For example, "
-"<literal>Hibernate.STRING</literal> represents the <literal>string</literal> "
-"type."
-msgstr ""
-"在 <literal>org.hibernate.Hibernate</literal> 中，定义了基础类型对应的 "
-"<literal>Type</literal> 常量。比如，<literal>Hibernate.STRING</literal> 代表 "
-"<literal>string</literal> 类型。"
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr "在 <literal>org.hibernate.Hibernate</literal> 中，定义了基础类型对应的 <literal>Type</literal> 常量。比如，<literal>Hibernate.STRING</literal> 代表 <literal>string</literal> 类型。"
#. Tag: title
#: basic_mapping.xml:2727
@@ -5114,53 +3436,25 @@
#. Tag: para
#: basic_mapping.xml:2729
#, fuzzy, no-c-format
-msgid ""
-"It is relatively easy for developers to create their own value types. For "
-"example, you might want to persist properties of type <literal>java.lang."
-"BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does "
-"not provide a built-in type for this. Custom types are not limited to "
-"mapping a property, or collection element, to a single table column. So, for "
-"example, you might have a Java property <literal>getName()</literal>/"
-"<literal>setName()</literal> of type <literal>java.lang.String</literal> "
-"that is persisted to the columns <literal>FIRST_NAME</literal>, "
-"<literal>INITIAL</literal>, <literal>SURNAME</literal>."
-msgstr ""
-"开发者创建属于他们自己的值类型也是很容易的。比如说，你可能希望持久化 "
-"<literal>java.lang.BigInteger</literal> 类型的属性，持久化成为 "
-"<literal>VARCHAR</literal> 字段。Hibernate没有内置这样一种类型。自定义类型能"
-"够映射一个属性(或集合元素)到不止一个数据库表字段。比如说，你可能有这样的 "
-"Java 属性：<literal>getName()</literal>/<literal>setName()</literal>，这是 "
-"<literal>java.lang.String</literal> 类型的，对应的持久化到三个字段："
-"<literal>FIRST_NAME</literal>，<literal>INITIAL</literal>，<literal>SURNAME</"
-"literal>。"
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. Custom types are not limited to mapping a property, or collection element, to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr "开发者创建属于他们自己的值类型也是很容易的。比如说，你可能希望持久化 <literal>java.lang.BigInteger</literal> 类型的属性，持久化成为 <literal>VARCHAR</literal> 字段。Hibernate没有内置这样一种类型。自定义类型能够映射一个属性(或集合元素)到不止一个数据库表字段。比如说，你可能有这样的 Java 属性：<literal>getName()</literal>/<literal>setName()</literal>，这是 <literal>java.lang.String</literal> 类型的，对应的持久化到三个字段：<literal>FIRST_NAME</literal>，<literal>INITIAL</literal>，<literal>SURNAME</literal>。"
#. Tag: para
#: basic_mapping.xml:2740
#, fuzzy, no-c-format
-msgid ""
-"To implement a custom type, implement either <literal>org.hibernate."
-"UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and "
-"declare properties using the fully qualified classname of the type. View "
-"<literal>org.hibernate.test.DoubleStringType</literal> to see the kind of "
-"things that are possible."
-msgstr ""
-"要实现一个自定义类型，可以实现 <literal>org.hibernate.UserType</literal> 或 "
-"<literal>org.hibernate.CompositeUserType</literal> 中的任一个，并且使用类型"
-"的 Java 全限定类名来定义属性。请查看 <literal>org.hibernate.test."
-"DoubleStringType</literal> 这个例子，看看它是怎么做的。"
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. View <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr "要实现一个自定义类型，可以实现 <literal>org.hibernate.UserType</literal> 或 <literal>org.hibernate.CompositeUserType</literal> 中的任一个，并且使用类型的 Java 全限定类名来定义属性。请查看 <literal>org.hibernate.test.DoubleStringType</literal> 这个例子，看看它是怎么做的。"
#. Tag: programlisting
#: basic_mapping.xml:2748
#, fuzzy, no-c-format
msgid ""
-"<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test."
-"DoubleStringType\">\n"
+"<![CDATA[<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
" <column name=\"first_string\"/>\n"
" <column name=\"second_string\"/>\n"
"</property>]]>"
msgstr ""
-"<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType"
-"\">\n"
+"<property name=\"twoStrings\" type=\"org.hibernate.test.DoubleStringType\">\n"
" <column name=\"first_string\"/>\n"
" <column name=\"second_string\"/>\n"
"</property>"
@@ -5168,40 +3462,20 @@
#. Tag: para
#: basic_mapping.xml:2750
#, no-c-format
-msgid ""
-"Notice the use of <literal><column></literal> tags to map a property "
-"to multiple columns."
-msgstr ""
-"注意使用 <literal><column></literal> 标签来把一个属性映射到多个字段的做"
-"法。"
+msgid "Notice the use of <literal><column></literal> tags to map a property to multiple columns."
+msgstr "注意使用 <literal><column></literal> 标签来把一个属性映射到多个字段的做法。"
#. Tag: para
#: basic_mapping.xml:2755
#, no-c-format
-msgid ""
-"The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</"
-"literal>, <literal>UserCollectionType</literal>, and "
-"<literal>UserVersionType</literal> interfaces provide support for more "
-"specialized uses."
-msgstr ""
-"<literal>CompositeUserType</literal>，<literal>EnhancedUserType</literal>，"
-"<literal>UserCollectionType</literal> 和 <literal>UserVersionType</literal> "
-"接口为更特殊的使用方式提供支持。"
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr "<literal>CompositeUserType</literal>，<literal>EnhancedUserType</literal>，<literal>UserCollectionType</literal> 和 <literal>UserVersionType</literal> 接口为更特殊的使用方式提供支持。"
#. Tag: para
#: basic_mapping.xml:2761
#, fuzzy, no-c-format
-msgid ""
-"You can even supply parameters to a <literal>UserType</literal> in the "
-"mapping file. To do this, your <literal>UserType</literal> must implement "
-"the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. "
-"To supply parameters to your custom type, you can use the <literal><"
-"type></literal> element in your mapping files."
-msgstr ""
-"你甚至可以在一个映射文件中提供参数给一个 <literal>UserType</literal>。 为了这"
-"样做，你的 <literal>UserType</literal> 必须实现 <literal>org.hibernate."
-"usertype.ParameterizedType</literal> 接口。为了给自定义类型提供参数，你可以在"
-"映射文件中使用 <literal><type></literal> 元素。"
+msgid "You can even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal><type></literal> element in your mapping files."
+msgstr "你甚至可以在一个映射文件中提供参数给一个 <literal>UserType</literal>。 为了这样做，你的 <literal>UserType</literal> 必须实现 <literal>org.hibernate.usertype.ParameterizedType</literal> 接口。为了给自定义类型提供参数，你可以在映射文件中使用 <literal><type></literal> 元素。"
#. Tag: programlisting
#: basic_mapping.xml:2769
@@ -5222,40 +3496,24 @@
#. Tag: para
#: basic_mapping.xml:2771
#, no-c-format
-msgid ""
-"The <literal>UserType</literal> can now retrieve the value for the parameter "
-"named <literal>default</literal> from the <literal>Properties</literal> "
-"object passed to it."
-msgstr ""
-"现在，<literal>UserType</literal> 可以从传入的 <literal>Properties</literal> "
-"对象中得到 <literal>default</literal> 参数的值。"
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr "现在，<literal>UserType</literal> 可以从传入的 <literal>Properties</literal> 对象中得到 <literal>default</literal> 参数的值。"
#. Tag: para
#: basic_mapping.xml:2776
#, fuzzy, no-c-format
-msgid ""
-"If you regularly use a certain <literal>UserType</literal>, it is useful to "
-"define a shorter name for it. You can do this using the <literal><"
-"typedef></literal> element. Typedefs assign a name to a custom type, and "
-"can also contain a list of default parameter values if the type is "
-"parameterized."
-msgstr ""
-"如果你非常频繁地使用某一 <literal>UserType</literal>，可以为他定义一个简称。"
-"这可以通过使用 <literal><typedef></literal> 元素来实现。Typedefs 为一自"
-"定义类型赋予一个名称，并且如果此类型是参数化的，还可以包含一系列默认的参数"
-"值。"
+msgid "If you regularly use a certain <literal>UserType</literal>, it is useful to define a shorter name for it. You can do this using the <literal><typedef></literal> element. Typedefs assign a name to a custom type, and can also contain a list of default parameter values if the type is parameterized."
+msgstr "如果你非常频繁地使用某一 <literal>UserType</literal>，可以为他定义一个简称。这可以通过使用 <literal><typedef></literal> 元素来实现。Typedefs 为一自定义类型赋予一个名称，并且如果此类型是参数化的，还可以包含一系列默认的参数值。"
#. Tag: programlisting
#: basic_mapping.xml:2783
#, fuzzy, no-c-format
msgid ""
-"<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" "
-"name=\"default_zero\">\n"
+"<![CDATA[<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
" <param name=\"default\">0</param>\n"
"</typedef>]]>"
msgstr ""
-"<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name="
-"\"default_zero\">\n"
+"<typedef class=\"com.mycompany.usertypes.DefaultValueIntegerType\" name=\"default_zero\">\n"
" <param name=\"default\">0</param>\n"
"</typedef>"
@@ -5268,30 +3526,14 @@
#. Tag: para
#: basic_mapping.xml:2787
#, no-c-format
-msgid ""
-"It is also possible to override the parameters supplied in a typedef on a "
-"case-by-case basis by using type parameters on the property mapping."
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
msgstr "也可以根据具体案例通过属性映射中的类型参数覆盖在 typedef 中提供的参数。"
#. Tag: para
#: basic_mapping.xml:2792
#, fuzzy, no-c-format
-msgid ""
-"Even though Hibernate's rich range of built-in types and support for "
-"components means you will rarely need to use a custom type, it is considered "
-"good practice to use custom types for non-entity classes that occur "
-"frequently in your application. For example, a <literal>MonetaryAmount</"
-"literal> class is a good candidate for a <literal>CompositeUserType</"
-"literal>, even though it could be mapped as a component. One reason for this "
-"is abstraction. With a custom type, your mapping documents would be "
-"protected against changes to the way monetary values are represented."
-msgstr ""
-"尽管 Hibernate 内建的丰富的类型和对组件的支持意味着你可能很少 <emphasis>需要"
-"</emphasis>使用自定义类型。不过，为那些在你的应用中经常出现的(非实体)类使用自"
-"定义类型也是一个好方法。例如，一个 <literal>MonetaryAmount</literal> 类使用 "
-"<literal>CompositeUserType</literal> 来映射是不错的选择，虽然他可以很容易地被"
-"映射成组件。这样做的动机之一是抽象。使用自定义类型，以后假若你改变表示金额的"
-"方法时，它可以保证映射文件不需要修改。"
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will rarely need to use a custom type, it is considered good practice to use custom types for non-entity classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could be mapped as a component. One reason for this is abstraction. With a custom type, your mapping documents would be protected against changes to the way monetary values are represented."
+msgstr "尽管 Hibernate 内建的丰富的类型和对组件的支持意味着你可能很少 <emphasis>需要</emphasis>使用自定义类型。不过，为那些在你的应用中经常出现的(非实体)类使用自定义类型也是一个好方法。例如，一个 <literal>MonetaryAmount</literal> 类使用 <literal>CompositeUserType</literal> 来映射是不错的选择，虽然他可以很容易地被映射成组件。这样做的动机之一是抽象。使用自定义类型，以后假若你改变表示金额的方法时，它可以保证映射文件不需要修改。"
#. Tag: title
#: basic_mapping.xml:2808
@@ -5302,18 +3544,8 @@
#. Tag: para
#: basic_mapping.xml:2809
#, fuzzy, no-c-format
-msgid ""
-"It is possible to provide more than one mapping for a particular persistent "
-"class. In this case, you must specify an <emphasis>entity name</emphasis> to "
-"disambiguate between instances of the two mapped entities. By default, the "
-"entity name is the same as the class name. Hibernate lets you specify the "
-"entity name when working with persistent objects, when writing queries, or "
-"when mapping associations to the named entity."
-msgstr ""
-"对特定的持久化类，映射多次是允许的。这种情形下，你必须指定 <emphasis>entity "
-"name</emphasis> 来区别不同映射实体的对象实例。（默认情况下，实体名字和类名是"
-"相同的。） Hibernate 在操作持久化对象、编写查询条件，或者把关联映射到指定实体"
-"时，允许你指定这个 entity name（实体名字）。"
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case, you must specify an <emphasis>entity name</emphasis> to disambiguate between instances of the two mapped entities. By default, the entity name is the same as the class name. Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr "对特定的持久化类，映射多次是允许的。这种情形下，你必须指定 <emphasis>entity name</emphasis> 来区别不同映射实体的对象实例。（默认情况下，实体名字和类名是相同的。） Hibernate 在操作持久化对象、编写查询条件，或者把关联映射到指定实体时，允许你指定这个 entity name（实体名字）。"
#. Tag: programlisting
#: basic_mapping.xml:2817
@@ -5358,12 +3590,8 @@
#. Tag: para
#: basic_mapping.xml:2819
#, fuzzy, no-c-format
-msgid ""
-"Associations are now specified using <literal>entity-name</literal> instead "
-"of <literal>class</literal>."
-msgstr ""
-"注意这里关联是如何用 <literal>entity-name</literal> 来代替 <literal>class</"
-"literal> 的。"
+msgid "Associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr "注意这里关联是如何用 <literal>entity-name</literal> 来代替 <literal>class</literal> 的。"
#. Tag: title
#: basic_mapping.xml:2827
@@ -5374,32 +3602,21 @@
#. Tag: para
#: basic_mapping.xml:2828
#, fuzzy, no-c-format
-msgid ""
-"You can force Hibernate to quote an identifier in the generated SQL by "
-"enclosing the table or column name in backticks in the mapping document. "
-"Hibernate will use the correct quotation style for the SQL <literal>Dialect</"
-"literal>. This is usually double quotes, but the SQL Server uses brackets "
-"and MySQL uses backticks."
-msgstr ""
-"你可通过在映射文档中使用反向引号（`）把表名或者字段名包围起来，以强制 "
-"Hibernate 在生成的 SQL 中把标识符用引号包围起来。Hibernate 会使用相应的 "
-"SQL<literal>Dialect</literal>（方言）来使用正确的引号风格(通常是双引号，但是"
-"在 SQL Server 中是括号，MySQL 中是反向引号)。"
+msgid "You can force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal>. This is usually double quotes, but the SQL Server uses brackets and MySQL uses backticks."
+msgstr "你可通过在映射文档中使用反向引号（`）把表名或者字段名包围起来，以强制 Hibernate 在生成的 SQL 中把标识符用引号包围起来。Hibernate 会使用相应的 SQL<literal>Dialect</literal>（方言）来使用正确的引号风格(通常是双引号，但是在 SQL Server 中是括号，MySQL 中是反向引号)。"
#. Tag: programlisting
#: basic_mapping.xml:2835
#, fuzzy, no-c-format
msgid ""
"<![CDATA[<class name=\"LineItem\" table=\"`Line Item`\">\n"
-" <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></"
-"id>\n"
+" <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
" <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
" ...\n"
"</class>]]>"
msgstr ""
"<class name=\"LineItem\" table=\"`Line Item`\">\n"
-" <id name=\"id\" column=\"`Item Id`\"/><generator class="
-"\"assigned\"/></id>\n"
+" <id name=\"id\" column=\"`Item Id`\"/><generator class=\"assigned\"/></id>\n"
" <property name=\"itemNumber\" column=\"`Item #`\"/>\n"
" ...\n"
"</class>"
@@ -5413,12 +3630,8 @@
#. Tag: para
#: basic_mapping.xml:2843
#, fuzzy, no-c-format
-msgid ""
-"XML does not suit all users so there are some alternative ways to define O/R "
-"mapping metadata in Hibernate."
-msgstr ""
-"XML 并不适用于所有人, 因此有其他定义 Hibernate O/R 映射元数据（metadata）的方"
-"法。"
+msgid "XML does not suit all users so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr "XML 并不适用于所有人, 因此有其他定义 Hibernate O/R 映射元数据（metadata）的方法。"
#. Tag: title
#: basic_mapping.xml:2848
@@ -5429,17 +3642,8 @@
#. Tag: para
#: basic_mapping.xml:2850
#, fuzzy, no-c-format
-msgid ""
-"Many Hibernate users prefer to embed mapping information directly in "
-"sourcecode using XDoclet <literal>@hibernate.tags</literal>. We do not cover "
-"this approach in this reference guide since it is considered part of "
-"XDoclet. However, we include the following example of the <literal>Cat</"
-"literal> class with XDoclet mappings:"
-msgstr ""
-"很多 Hibernate 使用者更喜欢使用 XDoclet<literal>@hibernate.tags</literal> 将"
-"映射信息直接嵌入到源代码中。我们不会在本文档中涉及这个方法，因为严格说来，这"
-"属于 XDoclet 的一部分。然而，我们包含了如下使用 XDoclet 映射的 <literal>Cat</"
-"literal> 类的例子。"
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We do not cover this approach in this reference guide since it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings:"
+msgstr "很多 Hibernate 使用者更喜欢使用 XDoclet<literal>@hibernate.tags</literal> 将映射信息直接嵌入到源代码中。我们不会在本文档中涉及这个方法，因为严格说来，这属于 XDoclet 的一部分。然而，我们包含了如下使用 XDoclet 映射的 <literal>Cat</literal> 类的例子。"
#. Tag: programlisting
#: basic_mapping.xml:2857
@@ -5670,25 +3874,8 @@
#. Tag: para
#: basic_mapping.xml:2868
#, fuzzy, no-c-format
-msgid ""
-"JDK 5.0 introduced XDoclet-style annotations at the language level that are "
-"type-safe and checked at compile time. This mechanism is more powerful than "
-"XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, "
-"for example, supports auto-completion and syntax highlighting of JDK 5.0 "
-"annotations. The new revision of the EJB specification (JSR-220) uses JDK "
-"5.0 annotations as the primary metadata mechanism for entity beans. "
-"Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the "
-"persistence API). Support for mapping metadata is available via the "
-"<emphasis>Hibernate Annotations</emphasis> package as a separate download. "
-"Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
-msgstr ""
-"JDK 5.0 在语言级别引入了 XDoclet 风格的标注，并且是类型安全的，在编译期进行检"
-"查。这一机制比 XDoclet 的注解更为强大，有更好的工具和 IDE 支持。例如，"
-"IntelliJ IDEA，支持 JDK 5.0 注解的自动完成和语法高亮 。EJB 规范的新修订版 "
-"(JSR-220) 使用 JDK 5.0 的注解作为entity beans的主要元数据（metadata）机制。"
-"Hibernate 3 实现了JSR-220(the persistence API) 的 <literal>EntityManager</"
-"literal>，支持通过 <emphasis>Hibernate Annotations</emphasis> 包定义映射元数"
-"据。这个包作为单独的部分下载，支持 EJB3(JSR-220) 和 Hibernate3 的元数据。"
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level that are type-safe and checked at compile time. This mechanism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API). Support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr "JDK 5.0 在语言级别引入了 XDoclet 风格的标注，并且是类型安全的，在编译期进行检查。这一机制比 XDoclet 的注解更为强大，有更好的工具和 IDE 支持。例如，IntelliJ IDEA，支持 JDK 5.0 注解的自动完成和语法高亮 。EJB 规范的新修订版 (JSR-220) 使用 JDK 5.0 的注解作为entity beans的主要元数据（metadata）机制。Hibernate 3 实现了JSR-220(the persistence API) 的 <literal>EntityManager</literal>，支持通过 <emphasis>Hibernate Annotations</emphasis> 包定义映射元数据。这个包作为单独的部分下载，支持 EJB3(JSR-220) 和 Hibernate3 的元数据。"
#. Tag: para
#: basic_mapping.xml:2879
@@ -5749,13 +3936,8 @@
#. Tag: para
#: basic_mapping.xml:2887
#, fuzzy, no-c-format
-msgid ""
-"Support for JDK 5.0 Annotations (and JSR-220) is currently under "
-"development. Please refer to the Hibernate Annotations module for more "
-"details."
-msgstr ""
-"注意：对 JDK 5.0 注解（和 JSR-220)支持的工作仍然在进行中,并未完成。更多细节请"
-"参阅 Hibernate Annotations 模块。"
+msgid "Support for JDK 5.0 Annotations (and JSR-220) is currently under development. Please refer to the Hibernate Annotations module for more details."
+msgstr "注意：对 JDK 5.0 注解（和 JSR-220)支持的工作仍然在进行中,并未完成。更多细节请参阅 Hibernate Annotations 模块。"
#. Tag: title
#: basic_mapping.xml:2897
@@ -5766,66 +3948,31 @@
#. Tag: para
#: basic_mapping.xml:2898
#, fuzzy, no-c-format
-msgid ""
-"Generated properties are properties that have their values generated by the "
-"database. Typically, Hibernate applications needed to <literal>refresh</"
-"literal> objects that contain any properties for which the database was "
-"generating values. Marking properties as generated, however, lets the "
-"application delegate this responsibility to Hibernate. When Hibernate issues "
-"an SQL INSERT or UPDATE for an entity that has defined generated properties, "
-"it immediately issues a select afterwards to retrieve the generated values."
-msgstr ""
-"Generated properties 指的是其值由数据库生成的属性。一般来说，如果对象有任何属"
-"性由数据库生成值，Hibernate 应用程序需要进行<literal>刷新（refresh）</"
-"literal>。但如果把属性标明为 generated，就可以转由 Hibernate 来负责这个动作。"
-"实际上。对定义了 generated properties 的实体,每当 Hibernate 执行一条 SQL "
-"INSERT 或者 UPDATE 语句，会立刻执行一条 select 来获得生成的值。"
+msgid "Generated properties are properties that have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects that contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. When Hibernate issues an SQL INSERT or UPDATE for an entity that has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr "Generated properties 指的是其值由数据库生成的属性。一般来说，如果对象有任何属性由数据库生成值，Hibernate 应用程序需要进行<literal>刷新（refresh）</literal>。但如果把属性标明为 generated，就可以转由 Hibernate 来负责这个动作。实际上。对定义了 generated properties 的实体,每当 Hibernate 执行一条 SQL INSERT 或者 UPDATE 语句，会立刻执行一条 select 来获得生成的值。"
#. Tag: para
#: basic_mapping.xml:2907
#, fuzzy, no-c-format
-msgid ""
-"Properties marked as generated must additionally be non-insertable and non-"
-"updateable. Only <xref linkend=\"mapping-declaration-version\"/>, <xref "
-"linkend=\"mapping-declaration-timestamp\"/>, and <xref linkend=\"mapping-"
-"declaration-property\"/>, can be marked as generated."
-msgstr ""
-"被标明为 generated 的属性还必须是 non-insertable 和 non-updateable 的。只有 "
-"<xref linkend=\"Mapping_declaration-version_optional\"/> versions、<xref "
-"linkend=\"Mapping_declaration-timestamp_optional\"/> timestamp 和 <xref "
-"linkend=\"Mapping_declaration-property\"/> 简单属性（simple properties）可以"
-"被标明为 generated。"
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\"/>, <xref linkend=\"mapping-declaration-timestamp\"/>, and <xref linkend=\"mapping-declaration-property\"/>, can be marked as generated."
+msgstr "被标明为 generated 的属性还必须是 non-insertable 和 non-updateable 的。只有 <xref linkend=\"Mapping_declaration-version_optional\"/> versions、<xref linkend=\"Mapping_declaration-timestamp_optional\"/> timestamp 和 <xref linkend=\"Mapping_declaration-property\"/> 简单属性（simple properties）可以被标明为 generated。"
#. Tag: para
#: basic_mapping.xml:2914
#, fuzzy, no-c-format
-msgid ""
-"<literal>never</literal> (the default): the given property value is not "
-"generated within the database."
+msgid "<literal>never</literal> (the default): the given property value is not generated within the database."
msgstr "<literal>never</literal>（默认）标明此属性值不是从数据库中生成。"
#. Tag: para
#: basic_mapping.xml:2918
#, fuzzy, no-c-format
-msgid ""
-"<literal>insert</literal>: the given property value is generated on insert, "
-"but is not regenerated on subsequent updates. Properties like created-date "
-"fall into this category. Even though <xref linkend=\"mapping-declaration-"
-"version\"/> and <xref linkend=\"mapping-declaration-timestamp\"/> properties "
-"can be marked as generated, this option is not available."
-msgstr ""
-"<literal>insert</literal> — 标明此属性值在 insert 的时候生成，但是不会在随后"
-"的 update 时重新生成。比如说创建日期就归属于这类。注意虽然 <xref linkend="
-"\"Mapping_declaration-version_optional\"/> version 和 <xref linkend="
-"\"Mapping_declaration-timestamp_optional\"/> timestamp 属性可以被标注为 "
-"generated，但是不适用这个选项..."
+msgid "<literal>insert</literal>: the given property value is generated on insert, but is not regenerated on subsequent updates. Properties like created-date fall into this category. Even though <xref linkend=\"mapping-declaration-version\"/> and <xref linkend=\"mapping-declaration-timestamp\"/> properties can be marked as generated, this option is not available."
+msgstr "<literal>insert</literal> — 标明此属性值在 insert 的时候生成，但是不会在随后的 update 时重新生成。比如说创建日期就归属于这类。注意虽然 <xref linkend=\"Mapping_declaration-version_optional\"/> version 和 <xref linkend=\"Mapping_declaration-timestamp_optional\"/> timestamp 属性可以被标注为 generated，但是不适用这个选项..."
#. Tag: para
#: basic_mapping.xml:2926
#, fuzzy, no-c-format
-msgid ""
-"<literal>always</literal>: the property value is generated both on insert "
-"and on update."
+msgid "<literal>always</literal>: the property value is generated both on insert and on update."
msgstr "<literal>always</literal> — 标明此属性值在 insert 和 update 时都会被生成。"
#. Tag: title
@@ -5837,29 +3984,13 @@
#. Tag: para
#: basic_mapping.xml:2934
#, fuzzy, no-c-format
-msgid ""
-"Auxiliary database objects allow for the CREATE and DROP of arbitrary "
-"database objects. In conjunction with Hibernate's schema evolution tools, "
-"they have the ability to fully define a user schema within the Hibernate "
-"mapping files. Although designed specifically for creating and dropping "
-"things like triggers or stored procedures, any SQL command that can be run "
-"via a <literal>java.sql.Statement.execute()</literal> method is valid (for "
-"example, ALTERs, INSERTS, etc.). There are essentially two modes for "
-"defining auxiliary database objects:"
-msgstr ""
-"允许 CREATE 和 DROP 任意数据库对象，与 Hibernate 的 schema 交互工具组合起来，"
-"可以提供在 Hibernate 映射文件中完全定义用户 schema 的能力。虽然这是为创建和销"
-"毁 trigger（触发器）或stored procedure（存储过程）等特别设计的，实际上任何可"
-"以在 <literal>java.sql.Statement.execute()</literal> 方法中执行的 SQL 命令都"
-"可以在此使用（比如ALTER, INSERT，等等）。本质上有两种模式来定义辅助数据库对"
-"象..."
+msgid "Auxiliary database objects allow for the CREATE and DROP of arbitrary database objects. In conjunction with Hibernate's schema evolution tools, they have the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid (for example, ALTERs, INSERTS, etc.). There are essentially two modes for defining auxiliary database objects:"
+msgstr "允许 CREATE 和 DROP 任意数据库对象，与 Hibernate 的 schema 交互工具组合起来，可以提供在 Hibernate 映射文件中完全定义用户 schema 的能力。虽然这是为创建和销毁 trigger（触发器）或stored procedure（存储过程）等特别设计的，实际上任何可以在 <literal>java.sql.Statement.execute()</literal> 方法中执行的 SQL 命令都可以在此使用（比如ALTER, INSERT，等等）。本质上有两种模式来定义辅助数据库对象..."
#. Tag: para
#: basic_mapping.xml:2943
#, fuzzy, no-c-format
-msgid ""
-"The first mode is to explicitly list the CREATE and DROP commands in the "
-"mapping file:"
+msgid "The first mode is to explicitly list the CREATE and DROP commands in the mapping file:"
msgstr "第一种模式是在映射文件中显式声明 CREATE 和 DROP 命令："
#. Tag: programlisting
@@ -5885,14 +4016,8 @@
#. Tag: para
#: basic_mapping.xml:2948
#, fuzzy, no-c-format
-msgid ""
-"The second mode is to supply a custom class that constructs the CREATE and "
-"DROP commands. This custom class must implement the <literal>org.hibernate."
-"mapping.AuxiliaryDatabaseObject</literal> interface."
-msgstr ""
-"第二种模式是提供一个类，这个类知道如何组织 CREATE 和 DROP 命令。这个特别类必"
-"须实现 <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> 接"
-"口。"
+msgid "The second mode is to supply a custom class that constructs the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr "第二种模式是提供一个类，这个类知道如何组织 CREATE 和 DROP 命令。这个特别类必须实现 <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> 接口。"
#. Tag: programlisting
#: basic_mapping.xml:2953
@@ -5915,9 +4040,7 @@
#. Tag: para
#: basic_mapping.xml:2954
#, fuzzy, no-c-format
-msgid ""
-"Additionally, these database objects can be optionally scoped so that they "
-"only apply when certain dialects are used."
+msgid "Additionally, these database objects can be optionally scoped so that they only apply when certain dialects are used."
msgstr "还有，这些数据库对象可以特别指定为仅在特定的方言中才使用。"
#. Tag: programlisting
@@ -5937,8 +4060,7 @@
" ...\n"
" <database-object>\n"
" <definition class=\"MyTriggerDefinition\"/>\n"
-" <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/"
-">\n"
+" <dialect-scope name=\"org.hibernate.dialect.Oracle9Dialect\"/>\n"
" <dialect-scope name=\"org.hibernate.dialect.OracleDialect\"/>\n"
" </database-object>\n"
"</hibernate-mapping>"
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/best_practices.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/best_practices.po 2009-11-05 23:28:47 UTC (rev 96068)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/best_practices.po 2009-11-06 00:14:23 UTC (rev 96069)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-06 10:05+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,86 +22,57 @@
#. Tag: term
#: best_practices.xml:33
-#, fuzzy, no-c-format
-msgid ""
-"Write fine-grained classes and map them using <literal><component></"
-"literal>:"
-msgstr ""
-"设计细颗粒度的持久类并且使用 <literal><component></literal> 来实现映"
-"射。"
+#, no-c-format
+msgid "Write fine-grained classes and map them using <literal><component></literal>:"
+msgstr "设计细颗粒度的持久类并且使用 <literal><component></literal> 来实现映射："
#. Tag: para
#: best_practices.xml:35
#, no-c-format
-msgid ""
-"Use an <literal>Address</literal> class to encapsulate <literal>street</"
-"literal>, <literal>suburb</literal>, <literal>state</literal>, "
-"<literal>postcode</literal>. This encourages code reuse and simplifies "
-"refactoring."
-msgstr ""
-"使用一个 <literal>Address</literal> 持久类来封装 <literal>street</literal>，"
-"<literal>suburb</literal>，<literal>state</literal>，<literal>postcode</"
-"literal>。 这将有利于代码重用和简化代码重构（refactoring）的工作。"
+msgid "Use an <literal>Address</literal> class to encapsulate <literal>street</literal>, <literal>suburb</literal>, <literal>state</literal>, <literal>postcode</literal>. This encourages code reuse and simplifies refactoring."
+msgstr "使用一个 <literal>Address</literal> 持久类来封装 <literal>street</literal>，<literal>suburb</literal>，<literal>state</literal>，<literal>postcode</literal>。 这将有利于代码重用和简化代码重构（refactoring）的工作。"
#. Tag: term
#: best_practices.xml:43
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Declare identifier properties on persistent classes:"
-msgstr "对持久类声明标识符属性（identifier properties）。"
+msgstr "对持久类声明标识符属性（identifier properties）："
#. Tag: para
#: best_practices.xml:45
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate makes identifier properties optional. There are a range of reasons "
-"why you should use them. We recommend that identifiers be 'synthetic', that "
-"is, generated with no business meaning."
-msgstr ""
-"Hibernate 中标识符属性是可选的，不过有很多原因来说明你应该使用标识符属性。我"
-"们建议标识符应该是“人造”的（自动生成，不涉及业务含义）。"
+#, no-c-format
+msgid "Hibernate makes identifier properties optional. There are a range of reasons why you should use them. We recommend that identifiers be 'synthetic', that is, generated with no business meaning."
+msgstr "Hibernate 中标识符属性是可选的，不过有很多原因来说明你应该使用标识符属性。我们建议标识符应该是“人造”的（自动生成，不涉及业务含义）。 "
#. Tag: term
#: best_practices.xml:53
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Identify natural keys:"
-msgstr "使用自然键（natural keys）标识"
+msgstr "使用自然键（natural keys）标识："
#. Tag: para
#: best_practices.xml:55
#, no-c-format
-msgid ""
-"Identify natural keys for all entities, and map them using <literal><"
-"natural-id></literal>. Implement <literal>equals()</literal> and "
-"<literal>hashCode()</literal> to compare the properties that make up the "
-"natural key."
-msgstr ""
-"对所有的实体都标识出自然键，用 <literal><natural-id></literal> 进行映"
-"射。实现 <literal>equals()</literal> 和 <literal>hashCode()</literal>，在其中"
-"用组成自然键的属性进行比较。"
+msgid "Identify natural keys for all entities, and map them using <literal><natural-id></literal>. Implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the properties that make up the natural key."
+msgstr "对所有的实体都标识出自然键，用 <literal><natural-id></literal> 进行映射。实现 <literal>equals()</literal> 和 <literal>hashCode()</literal>，在其中用组成自然键的属性进行比较。"
#. Tag: term
#: best_practices.xml:63
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Place each class mapping in its own file:"
-msgstr "为每个持久类写一个映射文件"
+msgstr "为每个持久类写一个映射文件："
#. Tag: para
#: best_practices.xml:65
-#, fuzzy, no-c-format
-msgid ""
-"Do not use a single monolithic mapping document. Map <literal>com.eg.Foo</"
-"literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes "
-"sense, particularly in a team environment."
-msgstr ""
-"不要把所有的持久类映射都写到一个大文件中。把 <literal>com.eg.Foo</literal> 映"
-"射到 <literal>com/eg/Foo.hbm.xml</literal> 中，在团队开发环境中，这一点显得特"
-"别有意义。"
+#, no-c-format
+msgid "Do not use a single monolithic mapping document. Map <literal>com.eg.Foo</literal> in the file <literal>com/eg/Foo.hbm.xml</literal>. This makes sense, particularly in a team environment."
+msgstr "不要把所有的持久类映射都写到一个大文件中。把 <literal>com.eg.Foo</literal> 映射到 <literal>com/eg/Foo.hbm.xml</literal> 中。在团队开发环境中，这一点尤其重要。"
#. Tag: term
#: best_practices.xml:73
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Load mappings as resources:"
-msgstr "把映射文件作为资源加载"
+msgstr "把映射文件作为资源加载："
#. Tag: para
#: best_practices.xml:75
@@ -111,20 +82,15 @@
#. Tag: term
#: best_practices.xml:81
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Consider externalizing query strings:"
-msgstr "考虑把查询字符串放在程序外面"
+msgstr "考虑把查询字符串放在程序外面："
#. Tag: para
#: best_practices.xml:83
-#, fuzzy, no-c-format
-msgid ""
-"This is recommended if your queries call non-ANSI-standard SQL functions. "
-"Externalizing the query strings to mapping files will make the application "
-"more portable."
-msgstr ""
-"如果你的查询中调用了非 ANSI 标准的 SQL 函数，那么这条实践经验对你适用。把查询"
-"字符串放在映射文件中可以让程序具有更好的可移植性。"
+#, no-c-format
+msgid "This is recommended if your queries call non-ANSI-standard SQL functions. Externalizing the query strings to mapping files will make the application more portable."
+msgstr "如果你的查询中调用了非 ANSI 标准的 SQL 函数，那么这条实践经验对你适用。把查询字符串放在映射文件中可以让程序具有更好的可移植性。 "
#. Tag: term
#: best_practices.xml:91
@@ -134,293 +100,151 @@
#. Tag: para
#: best_practices.xml:93
-#, fuzzy, no-c-format
-msgid ""
-"As in JDBC, always replace non-constant values by \"?\". Do not use string "
-"manipulation to bind a non-constant value in a query. You should also "
-"consider using named parameters in queries."
-msgstr ""
-"就像在 JDBC 编程中一样，应该总是用占位符 \"?\" 来替换非常量值，不要在查询中用"
-"字符串值来构造非常量值！更好的办法是在查询中使用命名参数。"
+#, no-c-format
+msgid "As in JDBC, always replace non-constant values by \"?\". Do not use string manipulation to bind a non-constant value in a query. You should also consider using named parameters in queries."
+msgstr "就像在 JDBC 编程中一样，应该总是用占位符 \"?\" 来替换非常量值，不要在查询中用字符串值来构造非常量值。你也应该考虑在查询中使用命名参数。"
#. Tag: term
#: best_practices.xml:101
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Do not manage your own JDBC connections:"
-msgstr "不要自己来管理 JDBC connections"
+msgstr "不要自己来管理 JDBC 连接："
#. Tag: para
#: best_practices.xml:103
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate allows the application to manage JDBC connections, but his "
-"approach should be considered a last-resort. If you cannot use the built-in "
-"connection providers, consider providing your own implementation of "
-"<literal>org.hibernate.connection.ConnectionProvider</literal>."
-msgstr ""
-"Hibernate 允许应用程序自己来管理 JDBC connections，但是应该作为最后没有办法的"
-"办法。如果你不能使用 Hibernate 内建的 connections providers，那么考虑实现自己"
-"来实现 <literal>org.hibernate.connection.ConnectionProvider</literal>。"
+#, no-c-format
+msgid "Hibernate allows the application to manage JDBC connections, but his approach should be considered a last-resort. If you cannot use the built-in connection providers, consider providing your own implementation of <literal>org.hibernate.connection.ConnectionProvider</literal>."
+msgstr "Hibernate 允许应用程序自己来管理 JDBC 连接，但是应该作为最后没有办法的办法。如果你不能使用 Hibernate 内建的 connections providers，那么考虑实现自己来实现 <literal>org.hibernate.connection.ConnectionProvider</literal>。"
#. Tag: term
#: best_practices.xml:111
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Consider using a custom type:"
-msgstr "考虑使用用户自定义类型（custom type）"
+msgstr "考虑使用用户自定义类型（custom type）："
#. Tag: para
#: best_practices.xml:113
-#, fuzzy, no-c-format
-msgid ""
-"Suppose you have a Java type from a library that needs to be persisted but "
-"does not provide the accessors needed to map it as a component. You should "
-"consider implementing <literal>org.hibernate.UserType</literal>. This "
-"approach frees the application code from implementing transformations to/"
-"from a Hibernate type."
-msgstr ""
-"假设你有一个 Java 类型，来自某些类库，需要被持久化，但是该类没有提供映射操作"
-"需要的存取方法。那么你应该考虑实现 <literal>org.hibernate.UserType</literal> "
-"接口。这种办法使程序代码写起来更加自如，不再需要考虑类与 Hibernate type 之间"
-"的相互转换。"
+#, no-c-format
+msgid "Suppose you have a Java type from a library that needs to be persisted but does not provide the accessors needed to map it as a component. You should consider implementing <literal>org.hibernate.UserType</literal>. This approach frees the application code from implementing transformations to/from a Hibernate type."
+msgstr "假设你有一个 Java 类型，来自某些类库，需要被持久化，但是该类没有提供映射操作需要的存取方法。那么你应该考虑实现 <literal>org.hibernate.UserType</literal> 接口。这种办法使程序代码写起来更加自如，不再需要考虑类与 Hibernate type 之间的相互转换。 "
#. Tag: term
#: best_practices.xml:122
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Use hand-coded JDBC in bottlenecks:"
-msgstr "在性能瓶颈的地方使用硬编码的 JDBC"
+msgstr "在性能瓶颈的地方使用硬编码的 JDBC："
#. Tag: para
#: best_practices.xml:124
-#, fuzzy, no-c-format
-msgid ""
-"In performance-critical areas of the system, some kinds of operations might "
-"benefit from direct JDBC. Do not assume, however, that JDBC is necessarily "
-"faster. Please wait until you <emphasis>know</emphasis> something is a "
-"bottleneck. If you need to use direct JDBC, you can open a Hibernate "
-"<literal>Session</literal> and usingfile:///usr/share/doc/HTML/en-US/index."
-"html that JDBC connection. This way you can still use the same transaction "
-"strategy and underlying connection provider."
-msgstr ""
-"在系统中对性能要求很严格的一些部分，某些操作也许直接使用 JDBC 会更好。但是请"
-"先<emphasis>确认</emphasis>这的确是一个瓶颈，并且不要想当然认为 JDBC 一定会更"
-"快。如果确实需要直接使用 JDBC，那么最好打开一个 Hibernate <literal>Session</"
-"literal> 然后从 <literal>Session</literal> 获得 connection，按照这种办法你仍"
-"然可以使用同样的 transaction 策略和底层的 connection provider。"
+#, no-c-format
+msgid "In performance-critical areas of the system, some kinds of operations might benefit from direct JDBC. Do not assume, however, that JDBC is necessarily faster. Please wait until you <emphasis>know</emphasis> something is a bottleneck. If you need to use direct JDBC, you can open a Hibernate <literal>Session</literal> and usingfile:///usr/share/doc/HTML/en-US/index.html that JDBC connection. This way you can still use the same transaction strategy and underlying connection provider."
+msgstr "在系统中对性能要求很严格的一些部分，某些操作也许直接使用 JDBC 会更好。但是请先<emphasis>确认</emphasis>这的确是一个瓶颈，并且不要想当然认为 JDBC 一定会更快。如果确实需要直接使用 JDBC，那么最好打开一个 Hibernate <literal>Session</literal> 然后从 <literal>Session</literal> 获得 connection，按照这种办法你仍然可以使用同样的 transaction 策略和底层的 connection provider。 "
#. Tag: term
#: best_practices.xml:134
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Understand <literal>Session</literal> flushing:"
-msgstr "理解 <literal>Session</literal> 清洗（ flushing）"
+msgstr "理解 <literal>Session</literal> 冲刷（flushing）："
#. Tag: para
#: best_practices.xml:136
-#, fuzzy, no-c-format
-msgid ""
-"Sometimes the Session synchronizes its persistent state with the database. "
-"Performance will be affected if this process occurs too often. You can "
-"sometimes minimize unnecessary flushing by disabling automatic flushing, or "
-"even by changing the order of queries and other operations within a "
-"particular transaction."
-msgstr ""
-"Session 会不时的向数据库同步持久化状态，如果这种操作进行的过于频繁，性能会受"
-"到一定的影响。有时候你可以通过禁止自动 flushing，尽量最小化非必要的 flushing "
-"操作，或者更进一步，在一个特定的 transaction 中改变查询和其它操作的顺序。"
+#, no-c-format
+msgid "Sometimes the Session synchronizes its persistent state with the database. Performance will be affected if this process occurs too often. You can sometimes minimize unnecessary flushing by disabling automatic flushing, or even by changing the order of queries and other operations within a particular transaction."
+msgstr "Session 会不时的向数据库同步持久化状态，如果这种操作进行的过于频繁，性能会受到一定的影响。有时候你可以通过禁止自动 flushing，尽量最小化非必要的 flushing 操作，或者更进一步，在一个特定的 transaction 中改变查询和其它操作的顺序。 "
#. Tag: term
#: best_practices.xml:145
-#, fuzzy, no-c-format
+#, no-c-format
msgid "In a three tiered architecture, consider using detached objects:"
-msgstr "在三层结构中，考虑使用托管对象（detached object）"
+msgstr "在三层结构中，考虑使用脱管对象（detached object）："
#. Tag: para
#: best_practices.xml:147
-#, fuzzy, no-c-format
-msgid ""
-"When using a servlet/session bean architecture, you can pass persistent "
-"objects loaded in the session bean to and from the servlet/JSP layer. Use a "
-"new session to service each request. Use <literal>Session.merge()</literal> "
-"or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the "
-"database."
-msgstr ""
-"当使用一个 servlet / session bean 类型的架构的时候, 你可以把已加载的持久对象"
-"在 session bean 层和 servlet / JSP 层之间来回传递。使用新的 session 来为每个"
-"请求服务，使用 <literal>Session.merge()</literal> 或者 <literal>Session."
-"saveOrUpdate()</literal> 来与数据库同步。"
+#, no-c-format
+msgid "When using a servlet/session bean architecture, you can pass persistent objects loaded in the session bean to and from the servlet/JSP layer. Use a new session to service each request. Use <literal>Session.merge()</literal> or <literal>Session.saveOrUpdate()</literal> to synchronize objects with the database."
+msgstr "当使用一个 servlet / session bean 类型的架构的时候, 你可以把已加载的持久对象在 session bean 层和 servlet / JSP 层之间来回传递。使用新的 session 来为每个请求服务，使用 <literal>Session.merge()</literal> 或者 <literal>Session.saveOrUpdate()</literal> 来与数据库同步。 "
#. Tag: term
#: best_practices.xml:156
-#, fuzzy, no-c-format
+#, no-c-format
msgid "In a two tiered architecture, consider using long persistence contexts:"
-msgstr "在两层结构中，考虑使用长持久上下文（long persistence contexts）."
+msgstr "在两层结构中，考虑使用长持久上下文（long persistence contexts）："
#. Tag: para
#: best_practices.xml:158
-#, fuzzy, no-c-format
-msgid ""
-"Database Transactions have to be as short as possible for best scalability. "
-"However, it is often necessary to implement long running "
-"<emphasis>application transactions</emphasis>, a single unit-of-work from "
-"the point of view of a user. An application transaction might span several "
-"client request/response cycles. It is common to use detached objects to "
-"implement application transactions. An appropriate alternative in a two "
-"tiered architecture, is to maintain a single open persistence contact "
-"session for the whole life cycle of the application transaction. Then simply "
-"disconnect from the JDBC connection at the end of each request and reconnect "
-"at the beginning of the subsequent request. Never share a single session "
-"across more than one application transaction or you will be working with "
-"stale data."
-msgstr ""
-"为了得到最佳的可伸缩性，数据库事务（Database Transaction）应该尽可能的短。但"
-"是，程序常常需要实现长时间运行的<emphasis>“应用程序事务（Application "
-"Transaction）”</emphasis>，包含一个从用户的观点来看的原子操作。这个应用程序事"
-"务可能跨越多次从用户请求到得到反馈的循环。用脱管对象（与 session 脱离的对象）"
-"来实现应用程序事务是常见的。或者，尤其在两层结构中，把 Hibernate Session 从"
-"JDBC连接中脱离开，下次需要用的时候再连接上。绝不要把一个 Session 用在多个应用"
-"程序事务（Application Transaction）中，否则你的数据可能会过期失效。"
+#, no-c-format
+msgid "Database Transactions have to be as short as possible for best scalability. However, it is often necessary to implement long running <emphasis>application transactions</emphasis>, a single unit-of-work from the point of view of a user. An application transaction might span several client request/response cycles. It is common to use detached objects to implement application transactions. An appropriate alternative in a two tiered architecture, is to maintain a single open persistence contact session for the whole life cycle of the application transaction. Then simply disconnect from the JDBC connection at the end of each request and reconnect at the beginning of the subsequent request. Never share a single session across more than one application transaction or you will be working with stale data."
+msgstr "为了得到最佳的可伸缩性，数据库事务（Database Transaction）应该尽可能的短。但是，程序常常需要实现长时间运行的<emphasis>“应用程序事务（Application Transaction）”</emphasis>，包含一个从用户的观点来看的原子操作。这个应用程序事务可能跨越多次从用户请求到得到反馈的循环。用脱管对象（与 session 脱离的对象）来实现应用程序事务是常见的。或者，尤其在两层结构中，把 Hibernate Session 从 JDBC 连接中脱离开，下次需要用的时候再连接上。绝不要把一个 Session 用在多个应用程序事务（Application Transaction）中，否则你的数据可能会过期失效。"
#. Tag: term
#: best_practices.xml:172
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Do not treat exceptions as recoverable:"
-msgstr "不要把异常看成可恢复的"
+msgstr "不要把异常看成可恢复的："
#. Tag: para
#: best_practices.xml:174
-#, fuzzy, no-c-format
-msgid ""
-"This is more of a necessary practice than a \"best\" practice. When an "
-"exception occurs, roll back the <literal>Transaction</literal> and close the "
-"<literal>Session</literal>. If you do not do this, Hibernate cannot "
-"guarantee that in-memory state accurately represents the persistent state. "
-"For example, do not use <literal>Session.load()</literal> to determine if an "
-"instance with the given identifier exists on the database; use "
-"<literal>Session.get()</literal> or a query instead."
-msgstr ""
-"这一点甚至比“最佳实践”还要重要，这是“必备常识”。当异常发生的时候，必须要回"
-"滚 <literal>Transaction</literal> ，关闭 <literal>Session</literal>。如果你"
-"不这样做的话，Hibernate无法保证内存状态精确的反应持久状态。尤其不要使用 "
-"<literal>Session.load()</literal> 来判断一个给定标识符的对象实例在数据库中是"
-"否存在，应该使用 <literal>Session.get()</literal> 或者进行一次查询."
+#, no-c-format
+msgid "This is more of a necessary practice than a \"best\" practice. When an exception occurs, roll back the <literal>Transaction</literal> and close the <literal>Session</literal>. If you do not do this, Hibernate cannot guarantee that in-memory state accurately represents the persistent state. For example, do not use <literal>Session.load()</literal> to determine if an instance with the given identifier exists on the database; use <literal>Session.get()</literal> or a query instead."
+msgstr "这一点甚至比“最佳实践”还要重要，这是“必备常识”。当异常发生的时候，必须要回滚 <literal>Transaction</literal> ，关闭 <literal>Session</literal>。如果你不这样做的话，Hibernate 无法保证内存状态精确的反应持久状态。尤其不要使用 <literal>Session.load()</literal> 来判断一个给定标识符的对象实例在数据库中是否存在，应该使用 <literal>Session.get()</literal> 或者进行一次查询。"
#. Tag: term
#: best_practices.xml:184
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Prefer lazy fetching for associations:"
-msgstr "对于关联优先考虑 lazy fetching。"
+msgstr "对于关联优先考虑 lazy fetching："
#. Tag: para
#: best_practices.xml:186
-#, fuzzy, no-c-format
-msgid ""
-"Use eager fetching sparingly. Use proxies and lazy collections for most "
-"associations to classes that are not likely to be completely held in the "
-"second-level cache. For associations to cached classes, where there is an a "
-"extremely high probability of a cache hit, explicitly disable eager fetching "
-"using <literal>lazy=\"false\"</literal>. When join fetching is appropriate "
-"to a particular use case, use a query with a <literal>left join fetch</"
-"literal>."
-msgstr ""
-"谨慎的使用主动抓取（eager fetching）。对于关联来说，若其目标是无法在第二级缓"
-"存中完全缓存所有实例的类，应该使用代理（proxies）与/或具有延迟加载属性的集合"
-"（lazy collections）。若目标是可以被缓存的，尤其是缓存的命中率非常高的情况"
-"下，应该使用 <literal>lazy=\"false\"</literal>，明确的禁止掉 eager fetching。"
-"如果那些特殊的确实适合使用 join fetch 的场合，请在查询中使用 <literal>left "
-"join fetch</literal>。"
+#, no-c-format
+msgid "Use eager fetching sparingly. Use proxies and lazy collections for most associations to classes that are not likely to be completely held in the second-level cache. For associations to cached classes, where there is an a extremely high probability of a cache hit, explicitly disable eager fetching using <literal>lazy=\"false\"</literal>. When join fetching is appropriate to a particular use case, use a query with a <literal>left join fetch</literal>."
+msgstr "谨慎的使用主动抓取（eager fetching）。对于关联来说，若其目标是无法在第二级缓存中完全缓存所有实例的类，应该使用代理（proxies）与/或具有延迟加载属性的集合（lazy collections）。若目标是可以被缓存的，尤其是缓存的命中率非常高的情况下，应该使用 <literal>lazy=\"false\"</literal>，明确的禁止掉 eager fetching。如果那些特殊的确实适合使用 join fetch 的场合，请在查询中使用 <literal>left join fetch</literal>。 "
#. Tag: term
#: best_practices.xml:196
-#, fuzzy, no-c-format
-msgid ""
-"Use the <emphasis>open session in view</emphasis> pattern, or a disciplined "
-"<emphasis>assembly phase</emphasis> to avoid problems with unfetched data:"
-msgstr ""
-"使用 <emphasis>open session in view</emphasis> 模式，或者执行严格的<emphasis>"
-"装配期（assembly phase）</emphasis>策略来避免再次抓取数据带来的问题"
+#, no-c-format
+msgid "Use the <emphasis>open session in view</emphasis> pattern, or a disciplined <emphasis>assembly phase</emphasis> to avoid problems with unfetched data:"
+msgstr "使用 <emphasis>open session in view</emphasis> 模式，或者执行严格的<emphasis>装配期（assembly phase）</emphasis>策略来避免再次抓取数据带来的问题："
#. Tag: para
#: best_practices.xml:201
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate frees the developer from writing tedious <emphasis>Data Transfer "
-"Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual "
-"purposes: first, they work around the problem that entity beans are not "
-"serializable; second, they implicitly define an assembly phase where all "
-"data to be used by the view is fetched and marshalled into the DTOs before "
-"returning control to the presentation tier. Hibernate eliminates the first "
-"purpose. Unless you are prepared to hold the persistence context (the "
-"session) open across the view rendering process, you will still need an "
-"assembly phase. Think of your business methods as having a strict contract "
-"with the presentation tier about what data is available in the detached "
-"objects. This is not a limitation of Hibernate. It is a fundamental "
-"requirement of safe transactional data access."
-msgstr ""
-"Hibernate 让开发者们摆脱了繁琐的 <emphasis>Data Transfer Objects</emphasis>"
-"（DTO）。在传统的 EJB 结构中，DTO 有双重作用：首先，他们解决了 entity bean 无"
-"法序列化的问题；其次，他们隐含地定义了一个装配期，在此期间，所有在 view 层需"
-"要用到的数据，都被抓取、集中到了 DTO 中，然后控制才被装到表示层。Hibernate 终"
-"结了第一个作用。然而，除非你做好了在整个渲染过程中都维护一个打开的持久化上下"
-"文（session）的准备，你仍然需要一个装配期（想象一下，你的业务方法与你的表示层"
-"有严格的契约，数据总是被放置到托管对象中）。这并非是 Hibernate 的限制！这是实"
-"现安全的事务化数据访问的基本需求。"
+#, no-c-format
+msgid "Hibernate frees the developer from writing tedious <emphasis>Data Transfer Objects</emphasis> (DTO). In a traditional EJB architecture, DTOs serve dual purposes: first, they work around the problem that entity beans are not serializable; second, they implicitly define an assembly phase where all data to be used by the view is fetched and marshalled into the DTOs before returning control to the presentation tier. Hibernate eliminates the first purpose. Unless you are prepared to hold the persistence context (the session) open across the view rendering process, you will still need an assembly phase. Think of your business methods as having a strict contract with the presentation tier about what data is available in the detached objects. This is not a limitation of Hibernate. It is a fundamental requirement of safe transactional data access."
+msgstr "Hibernate 让开发者们摆脱了繁琐的 <emphasis>Data Transfer Objects</emphasis>（DTO）。在传统的 EJB 结构中，DTO 有双重作用：首先，他们解决了 entity bean 无法序列化的问题；其次，他们隐含地定义了一个装配期，在此期间，所有在 view 层需要用到的数据，都被抓取、集中到了 DTO 中，然后控制才被装到表示层。Hibernate 终结了第一个作用。然而，除非你做好了在整个渲染过程中都维护一个打开的持久化上下文（session）的准备，你仍然需要一个装配期（想象一下，你的业务方法与你的表示层有严格的契约，数据总是被放置到脱管对象中）。这并非是 Hibernate 的限制，这是实现安全的事务化数据访问的基本需求。"
#. Tag: term
#: best_practices.xml:215
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Consider abstracting your business logic from Hibernate:"
-msgstr "考虑把 Hibernate 代码从业务逻辑代码中抽象出来"
+msgstr "考虑把 Hibernate 代码从业务逻辑代码中抽象出来："
#. Tag: para
#: best_practices.xml:217
-#, fuzzy, no-c-format
-msgid ""
-"Hide Hibernate data-access code behind an interface. Combine the "
-"<emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> "
-"patterns. You can even have some classes persisted by handcoded JDBC "
-"associated to Hibernate via a <literal>UserType</literal>. This advice is, "
-"however, intended for \"sufficiently large\" applications. It is not "
-"appropriate for an application with five tables."
-msgstr ""
-"把 Hibernate 的数据存取代码隐藏到接口（interface）的后面，组合使用 "
-"<emphasis>DAO</emphasis> 和 <emphasis>Thread Local Session</emphasis> 模式。"
-"通过 Hibernate 的<literal>UserType</literal>，你甚至可以用硬编码的 JDBC 来持"
-"久化那些本该被 Hibernate 持久化的类。（该建议更适用于规模足够大应用软件中，对"
-"于那些只有 5 张表的应用程序并不适合。）"
+#, no-c-format
+msgid "Hide Hibernate data-access code behind an interface. Combine the <emphasis>DAO</emphasis> and <emphasis>Thread Local Session</emphasis> patterns. You can even have some classes persisted by handcoded JDBC associated to Hibernate via a <literal>UserType</literal>. This advice is, however, intended for \"sufficiently large\" applications. It is not appropriate for an application with five tables."
+msgstr "把 Hibernate 的数据存取代码隐藏到接口（interface）的后面，组合使用 <emphasis>DAO</emphasis> 和 <emphasis>Thread Local Session</emphasis> 模式。通过 Hibernate 的<literal>UserType</literal>，你甚至可以用硬编码的 JDBC 来持久化那些本该被 Hibernate 持久化的类。然而，该建议更适用于规模足够大应用软件中，对于那些只有 5 张表的应用程序并不适合。"
#. Tag: term
#: best_practices.xml:227
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Do not use exotic association mappings:"
-msgstr "不要用怪异的连接映射"
+msgstr "不要用怪异的连接映射："
#. Tag: para
#: best_practices.xml:229
-#, fuzzy, no-c-format
-msgid ""
-"Practical test cases for real many-to-many associations are rare. Most of "
-"the time you need additional information stored in the \"link table\". In "
-"this case, it is much better to use two one-to-many associations to an "
-"intermediate link class. In fact, most associations are one-to-many and many-"
-"to-one. For this reason, you should proceed cautiously when using any other "
-"association style."
-msgstr ""
-"多对多连接用得好的例子实际上相当少见。大多数时候你在“连接表”中需要保存额外的"
-"信息。这种情况下，用两个指向中介类的一对多的连接比较好。实际上，我们认为绝大"
-"多数的连接是一对多和多对一的，你应该谨慎使用其它连接风格，用之前问自己一句，"
-"是否真的必须这么做。"
+#, no-c-format
+msgid "Practical test cases for real many-to-many associations are rare. Most of the time you need additional information stored in the \"link table\". In this case, it is much better to use two one-to-many associations to an intermediate link class. In fact, most associations are one-to-many and many-to-one. For this reason, you should proceed cautiously when using any other association style."
+msgstr "多对多连接用得好的例子实际上相当少见。大多数时候你在“连接表”中需要保存额外的信息。这种情况下，用两个指向中介类的一对多的连接比较好。实际上，我们认为绝大多数的连接是一对多和多对一的。i因此，你应该谨慎使用其它连接风格。"
#. Tag: term
#: best_practices.xml:239
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Prefer bidirectional associations:"
-msgstr "偏爱双向关联"
+msgstr "偏爱双向关联："
#. Tag: para
#: best_practices.xml:241
#, no-c-format
-msgid ""
-"Unidirectional associations are more difficult to query. In a large "
-"application, almost all associations must be navigable in both directions in "
-"queries."
-msgstr ""
-"单向关联更加难于查询。在大型应用中，几乎所有的关联必须在查询中可以双向导航。"
+msgid "Unidirectional associations are more difficult to query. In a large application, almost all associations must be navigable in both directions in queries."
+msgstr "单向关联更加难于查询。在大型应用中，几乎所有的关联必须在查询中可以双向导航。"
+
More information about the jboss-cvs-commits
mailing list