[jboss-cvs] JBossAS SVN: r97495 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Mon Dec 7 06:14:45 EST 2009
Author: xhuang at jboss.com
Date: 2009-12-07 06:14:45 -0500 (Mon, 07 Dec 2009)
New Revision: 97495
Modified:
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/inheritance_mapping.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/performance.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/persistent_classes.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/portability.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_criteria.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_hql.po
Log:
update
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/inheritance_mapping.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/inheritance_mapping.po 2009-12-07 10:21:17 UTC (rev 97494)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/inheritance_mapping.po 2009-12-07 11:14:45 UTC (rev 97495)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:26\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-12-07 09:35+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -15,14 +15,14 @@
"X-Generator: KBabel 1.11.4\n"
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Inheritance mapping"
-msgstr "继承映射（Inheritance Mapping）"
+msgstr "继承映射（Inheritance Mapping） "
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The three strategies"
-msgstr "三种策略"
+msgstr "三种策略 "
#. Tag: para
#, no-c-format
@@ -35,9 +35,9 @@
msgstr "每个类分层结构一张表（table per class hierarchy）"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "table per subclass"
-msgstr "每个子类一张表（Table per subclass）"
+msgstr "每个子类一张表（Table per subclass） "
#. Tag: para
#, no-c-format
@@ -46,9 +46,7 @@
#. Tag: para
#, no-c-format
-msgid ""
-"In addition, Hibernate supports a fourth, slightly different kind of "
-"polymorphism:"
+msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
msgstr "此外，Hibernate 还支持第四种稍有不同的多态映射策略："
#. Tag: para
@@ -57,49 +55,14 @@
msgstr "隐式多态（implicit polymorphism）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is possible to use different mapping strategies for different branches of "
-"the same inheritance hierarchy. You can then make use of implicit "
-"polymorphism to achieve polymorphism across the whole hierarchy. However, "
-"Hibernate does not support mixing <literal><subclass></literal>, "
-"<literal><joined-subclass></literal> and <literal><union-"
-"subclass></literal> mappings under the same root <literal><class></"
-"literal> element. It is possible to mix together the table per hierarchy and "
-"table per subclass strategies under the the same <literal><class></"
-"literal> element, by combining the <literal><subclass></literal> and "
-"<literal><join></literal> elements (see below for an example)."
-msgstr ""
-"对于同一个继承层次内的不同分支，可以采用不同的映射策略，然后用隐式多 态来完成"
-"跨越整个层次的多态。但是在同一个 <literal><class></literal> 根元素下，"
-"Hibernate 不支持混合了元素 <literal><subclass></literal>、<literal><"
-"joined-subclass></literal> 和 <literal><union-subclass></literal> 的"
-"映射。在同一个 <literal><class></literal> 元素下，可以混合使用“每个类分"
-"层结构一张表”（table per hierarchy）和“每个子类一张表”（table per subclass） "
-"这两种映射策略，这是通过结合元素 <literal><subclass></literal> 和 "
-"<literal><join></literal> 来实现的（见后）。"
+#, no-c-format
+msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy. You can then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal><subclass></literal>, <literal><joined-subclass></literal> and <literal><union-subclass></literal> mappings under the same root <literal><class></literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies under the the same <literal><class></literal> element, by combining the <literal><subclass></literal> and <literal><join></literal> elements (see below for an example)."
+msgstr "对于同一个继承层次内的不同分支，可以采用不同的映射策略，然后用隐式多 态来完成跨越整个层次的多态。但是在同一个 <literal><class></literal> 根元素下，Hibernate 不支持混合了元素 <literal><subclass></literal>、<literal><joined-subclass></literal> 和 <literal><union-subclass></literal> 的映射。在同一个 <literal><class></literal> 元素下，可以混合使用“每个类分层结构一张表”（table per hierarchy）和“每个子类一张表”（table per subclass） 这两种映射策略，这是通过结合元素 <literal><subclass></literal> 和 <literal><join></literal> 来实现的（见后）。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is possible to define <literal>subclass</literal>, <literal>union-"
-"subclass</literal>, and <literal>joined-subclass</literal> mappings in "
-"separate mapping documents directly beneath <literal>hibernate-mapping</"
-"literal>. This allows you to extend a class hierarchy by adding a new "
-"mapping file. You must specify an <literal>extends</literal> attribute in "
-"the subclass mapping, naming a previously mapped superclass. Previously this "
-"feature made the ordering of the mapping documents important. Since "
-"Hibernate3, the ordering of mapping files is irrelevant when using the "
-"extends keyword. The ordering inside a single mapping file still needs to be "
-"defined as superclasses before subclasses."
-msgstr ""
-"在多个映射文件中，可以直接在 <literal>hibernate-mapping</literal> 根下定义 "
-"<literal>subclass</literal>，<literal>union-subclass</literal> 和 "
-"<literal>joined-subclass</literal>。也就是说，你可以仅加入一个新的映射文件来"
-"扩展类层次。你必须在 subclass 的映射中指明 <literal>extends</literal> 属性，"
-"给出一个之前定义的超类的名字。注意，在以前，这一功能对映射文件的顺序有严格的"
-"要求，从 Hibernate 3 开始，使用 extends 关键字的时侯，对映射文件的顺序不再有"
-"要求；但在每个映射文件里，超类必须在子类之前定义。"
+#, no-c-format
+msgid "It is possible to define <literal>subclass</literal>, <literal>union-subclass</literal>, and <literal>joined-subclass</literal> mappings in separate mapping documents directly beneath <literal>hibernate-mapping</literal>. This allows you to extend a class hierarchy by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files is irrelevant when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
+msgstr "在多个映射文件中，可以直接在 <literal>hibernate-mapping</literal> 根下定义 <literal>subclass</literal>，<literal>union-subclass</literal> 和 <literal>joined-subclass</literal>。也就是说，你可以仅加入一个新的映射文件来扩展类层次。你必须在 subclass 的映射中指明 <literal>extends</literal> 属性，给出一个之前定义的超类的名字。注意，在以前，这一功能对映射文件的顺序有严格的要求，从 Hibernate 3 开始，使用 extends 关键字的时侯，对映射文件的顺序不再有要求；但在每个映射文件里，超类必须在子类之前定义。 "
#. Tag: title
#, no-c-format
@@ -107,27 +70,14 @@
msgstr "每个类分层结构一张表（Table per class hierarchy）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Suppose we have an interface <literal>Payment</literal> with the "
-"implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</"
-"literal>, and <literal>ChequePayment</literal>. The table per hierarchy "
-"mapping would display in the following way:"
-msgstr ""
-"假设我们有接口<literal>Payment</literal>和它的几个实现类： "
-"<literal>CreditCardPayment</literal>, <literal>CashPayment</literal> 和"
-"<literal>ChequePayment</literal>。则“每个类分层结构一张表”（Table per class "
-"hierarchy）的映射代码如下所示："
+#, no-c-format
+msgid "Suppose we have an interface <literal>Payment</literal> with the implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, and <literal>ChequePayment</literal>. The table per hierarchy mapping would display in the following way:"
+msgstr "假设我们有接口<literal>Payment</literal>和它的几个实现类： <literal>CreditCardPayment</literal>, <literal>CashPayment</literal> 和<literal>ChequePayment</literal>。则“每个类分层结构一张表”（Table per class hierarchy）的映射代码如下所示： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Exactly one table is required. There is a limitation of this mapping "
-"strategy: columns declared by the subclasses, such as <literal>CCTYPE</"
-"literal>, cannot have <literal>NOT NULL</literal> constraints."
-msgstr ""
-"采用这种策略只需要一张表即可。它有一个很大的限制：要求那些由子类定义的字段， "
-"如 <literal>CCTYPE</literal>，不能有<literal>非空（NOT NULL）</literal>约束。"
+#, no-c-format
+msgid "Exactly one table is required. There is a limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, cannot have <literal>NOT NULL</literal> constraints."
+msgstr "采用这种策略只需要一张表即可。它有一个很大的限制：要求那些由子类定义的字段， 如 <literal>CCTYPE</literal>，不能有<literal>非空（NOT NULL）</literal>约束。 "
#. Tag: title
#, no-c-format
@@ -135,54 +85,29 @@
msgstr "每个子类一张表（Table per subclass）"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "A table per subclass mapping looks like this:"
-msgstr "对于上例中的几个类而言，采用“每个子类一张表”的映射策略，代码如下所示："
+msgstr " 对于上例中的几个类而言，采用“每个子类一张表”的映射策略，代码如下所示："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Four tables are required. The three subclass tables have primary key "
-"associations to the superclass table so the relational model is actually a "
-"one-to-one association."
-msgstr ""
-"需要四张表。三个子类表通过主键关联到超类表（因而关系模型实际上是一对一关"
-"联）。"
+#, no-c-format
+msgid "Four tables are required. The three subclass tables have primary key associations to the superclass table so the relational model is actually a one-to-one association."
+msgstr "需要四张表。三个子类表通过主键关联到超类表（因而关系模型实际上是一对一关联）。 "
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Table per subclass: using a discriminator"
-msgstr "每个子类一张表（Table per subclass），使用辨别标志（Discriminator）"
+msgstr "每个子类一张表（Table per subclass），使用辨别标志（Discriminator） "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate's implementation of table per subclass does not require a "
-"discriminator column. Other object/relational mappers use a different "
-"implementation of table per subclass that requires a type discriminator "
-"column in the superclass table. The approach taken by Hibernate is much more "
-"difficult to implement, but arguably more correct from a relational point of "
-"view. If you want to use a discriminator column with the table per subclass "
-"strategy, you can combine the use of <literal><subclass></literal> and "
-"<literal><join></literal>, as follows:"
-msgstr ""
-"注意，对“每个子类一张表”的映射策略，Hibernate 的实现不需要辨别字段，而其他的"
-"对象／关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类表中有"
-"一个类型辨别字段（type discriminator column）。Hibernate 采用的方法更难实现，"
-"但从关系（数据库）的角度来看，按理说它更正确。若你愿意使用带有辨别字段的“每个"
-"子类一张表”的策略，你可以结合使用 <literal><subclass></literal> 与"
-"<literal><join></literal>，如下所示："
+#, no-c-format
+msgid "Hibernate's implementation of table per subclass does not require a discriminator column. Other object/relational mappers use a different implementation of table per subclass that requires a type discriminator column in the superclass table. The approach taken by Hibernate is much more difficult to implement, but arguably more correct from a relational point of view. If you want to use a discriminator column with the table per subclass strategy, you can combine the use of <literal><subclass></literal> and <literal><join></literal>, as follows:"
+msgstr "注意，对“每个子类一张表”的映射策略，Hibernate 的实现不需要辨别字段，而其他的对象／关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类表中有一个类型辨别字段（type discriminator column）。Hibernate 采用的方法更难实现，但从关系（数据库）的角度来看，按理说它更正确。若你愿意使用带有辨别字段的“每个子类一张表”的策略，你可以结合使用 <literal><subclass></literal> 与<literal><join></literal>，如下所示： "
#. Tag: para
#, no-c-format
-msgid ""
-"The optional <literal>fetch=\"select\"</literal> declaration tells Hibernate "
-"not to fetch the <literal>ChequePayment</literal> subclass data using an "
-"outer join when querying the superclass."
-msgstr ""
-"可选的声明 <literal>fetch=\"select\"</literal>，是用来告诉 Hibernate，在查询"
-"超类时，不要使用外部连接（outer join）来抓取子类 <literal>ChequePayment</"
-"literal> 的数据。"
+msgid "The optional <literal>fetch=\"select\"</literal> declaration tells Hibernate not to fetch the <literal>ChequePayment</literal> subclass data using an outer join when querying the superclass."
+msgstr "可选的声明 <literal>fetch=\"select\"</literal>，是用来告诉 Hibernate，在查询超类时，不要使用外部连接（outer join）来抓取子类 <literal>ChequePayment</literal> 的数据。"
#. Tag: title
#, no-c-format
@@ -190,23 +115,14 @@
msgstr "混合使用“每个类分层结构一张表”和“每个子类一张表”"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can even mix the table per hierarchy and table per subclass strategies "
-"using the following approach:"
-msgstr ""
-"你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种"
-"策略："
+#, no-c-format
+msgid "You can even mix the table per hierarchy and table per subclass strategies using the following approach:"
+msgstr "你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种策略： "
#. Tag: para
#, no-c-format
-msgid ""
-"For any of these mapping strategies, a polymorphic association to the root "
-"<literal>Payment</literal> class is mapped using <literal><many-to-one>"
-"</literal>."
-msgstr ""
-"对上述任何一种映射策略而言，指向根类 <literal>Payment</literal> 的关联是使用 "
-"<literal><many-to-one></literal> 进行映射的。"
+msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal><many-to-one></literal>."
+msgstr "对上述任何一种映射策略而言，指向根类 <literal>Payment</literal> 的关联是使用 <literal><many-to-one></literal> 进行映射的。"
#. Tag: title
#, no-c-format
@@ -214,54 +130,29 @@
msgstr "每个具体类一张表（Table per concrete class）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"There are two ways we can map the table per concrete class strategy. First, "
-"you can use <literal><union-subclass></literal>."
-msgstr ""
-"对于“每个具体类一张表”的映射策略，可以采用两种方法。第一种方法是使用 "
-"<literal><union-subclass></literal>。"
+#, no-c-format
+msgid "There are two ways we can map the table per concrete class strategy. First, you can use <literal><union-subclass></literal>."
+msgstr "对于“每个具体类一张表”的映射策略，可以采用两种方法。第一种方法是使用 <literal><union-subclass></literal>。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Three tables are involved for the subclasses. Each table defines columns for "
-"all properties of the class, including inherited properties."
-msgstr ""
-"这里涉及三张与子类相关的表。每张表为对应类的所有属性（包括从超类继承的属性）"
-"定义相应字段。"
+msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
+msgstr "这里涉及三张与子类相关的表。每张表为对应类的所有属性（包括从超类继承的属性）定义相应字段。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The limitation of this approach is that if a property is mapped on the "
-"superclass, the column name must be the same on all subclass tables. The "
-"identity generator strategy is not allowed in union subclass inheritance. "
-"The primary key seed has to be shared across all unioned subclasses of a "
-"hierarchy."
-msgstr ""
-"这种方式的局限在于，如果一个属性在超类中做了映射，其字段名必须与所有子类表中"
-"定义的相同。（我们可能会在 Hibernate 的后续发布版本中放宽此限制。）不允许在联"
-"合子类（union subclass）的继承层次中使用标识生成器策略（identity generator "
-"strategy），实际上，主键的种子（primary key seed）不得不为同一继承层次中的全"
-"部被联合子类所共用。"
+#, no-c-format
+msgid "The limitation of this approach is that if a property is mapped on the superclass, the column name must be the same on all subclass tables. The identity generator strategy is not allowed in union subclass inheritance. The primary key seed has to be shared across all unioned subclasses of a hierarchy."
+msgstr "这种方式的局限在于，如果一个属性在超类中做了映射，其字段名必须与所有子类表中定义的相同。（我们可能会在 Hibernate 的后续发布版本中放宽此限制。）不允许在联合子类（union subclass）的继承层次中使用标识生成器策略（identity generator strategy），实际上，主键的种子（primary key seed）不得不为同一继承层次中的全部被联合子类所共用。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If your superclass is abstract, map it with <literal>abstract=\"true\"</"
-"literal>. If it is not abstract, an additional table (it defaults to "
-"<literal>PAYMENT</literal> in the example above), is needed to hold "
-"instances of the superclass."
-msgstr ""
-"假若超类是抽象类，请使用 <literal>abstract=\"true\"</literal>。当然，假若它不"
-"是抽象的，需要一个额外的表（上面的例子中，默认是 <literal>PAYMENT</"
-"literal>），来保存超类的实例。"
+#, no-c-format
+msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. If it is not abstract, an additional table (it defaults to <literal>PAYMENT</literal> in the example above), is needed to hold instances of the superclass."
+msgstr "假若超类是抽象类，请使用 <literal>abstract=\"true\"</literal>。当然，假若它不是抽象的，需要一个额外的表（上面的例子中，默认是 <literal>PAYMENT</literal>），来保存超类的实例。 "
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Table per concrete class using implicit polymorphism"
-msgstr "每个具体类一张表，使用隐式多态"
+msgstr "每个具体类一张表，使用隐式多态 "
#. Tag: para
#, no-c-format
@@ -270,32 +161,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Notice that the <literal>Payment</literal> interface is not mentioned "
-"explicitly. Also notice that properties of <literal>Payment</literal> are "
-"mapped in each of the subclasses. If you want to avoid duplication, consider "
-"using XML entities (for example, <literal>[ <!ENTITY allproperties SYSTEM "
-"\"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> "
-"declaration and <literal>&allproperties;</literal> in the mapping)."
-msgstr ""
+msgid "Notice that the <literal>Payment</literal> interface is not mentioned explicitly. Also notice that properties of <literal>Payment</literal> are mapped in each of the subclasses. If you want to avoid duplication, consider using XML entities (for example, <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> in the <literal>DOCTYPE</literal> declaration and <literal>&allproperties;</literal> in the mapping)."
+msgstr "请注意这里没有显性地提及 <literal>Payment</literal> 接口。<literal>Payment</literal> 的属性映射到每个子类。如果你想避免重复，请考虑使用 XML 实体（如：<literal>DOCTYPE</literal> 声明里的 <literal>[ <!ENTITY allproperties SYSTEM \"allproperties.xml\"> ]</literal> 和映射里的 <literal>&allproperties;</literal>）。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The disadvantage of this approach is that Hibernate does not generate SQL "
-"<literal>UNION</literal>s when performing polymorphic queries."
-msgstr ""
-"这种方法的缺陷在于，在 Hibernate 执行多态查询时（polymorphic queries）无法生"
-"成带 <literal>UNION</literal> 的 SQL 语句。"
+#, no-c-format
+msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
+msgstr "这种方法的缺陷在于，在 Hibernate 执行多态查询时（polymorphic queries）无法生成带 <literal>UNION</literal> 的 SQL 语句。 "
#. Tag: para
#, no-c-format
-msgid ""
-"For this mapping strategy, a polymorphic association to <literal>Payment</"
-"literal> is usually mapped using <literal><any></literal>."
-msgstr ""
-"对于这种映射策略而言，通常用 <literal><any></literal> 来实现到 "
-"<literal>Payment</literal> 的多态关联映射。"
+msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal><any></literal>."
+msgstr "对于这种映射策略而言，通常用 <literal><any></literal> 来实现到 <literal>Payment</literal> 的多态关联映射。"
#. Tag: title
#, no-c-format
@@ -303,36 +180,14 @@
msgstr "隐式多态和其他继承映射混合使用"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Since the subclasses are each mapped in their own <literal><class></"
-"literal> element, and since <literal>Payment</literal> is just an "
-"interface), each of the subclasses could easily be part of another "
-"inheritance hierarchy. You can still use polymorphic queries against the "
-"<literal>Payment</literal> interface."
-msgstr ""
-"对这一映射还有一点需要注意。因为每个子类都在各自独立的元素 <literal><"
-"class></literal> 中映射（并且 <literal>Payment</literal> 只是一个接口），"
-"每个子类可以很容易的成为另一个继承体系中的一部分！（你仍然可以对接口 "
-"<literal>Payment</literal> 使用多态查询。）"
+#, no-c-format
+msgid "Since the subclasses are each mapped in their own <literal><class></literal> element, and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy. You can still use polymorphic queries against the <literal>Payment</literal> interface."
+msgstr "对这一映射还有一点需要注意。因为每个子类都在各自独立的元素 <literal><class></literal> 中映射（并且 <literal>Payment</literal> 只是一个接口），每个子类可以很容易的成为另一个继承体系中的一部分！（你仍然可以对接口 <literal>Payment</literal> 使用多态查询。） "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Once again, <literal>Payment</literal> is not mentioned explicitly. If we "
-"execute a query against the <literal>Payment</literal> interface, for "
-"example <literal>from Payment</literal>, Hibernate automatically returns "
-"instances of <literal>CreditCardPayment</literal> (and its subclasses, since "
-"they also implement <literal>Payment</literal>), <literal>CashPayment</"
-"literal> and <literal>ChequePayment</literal>, but not instances of "
-"<literal>NonelectronicTransaction</literal>."
-msgstr ""
-"我们还是没有明确的提到 <literal>Payment</literal>。如果我们针对接口 "
-"<literal>Payment</literal> 执行查询 — 如 <literal>from Payment</literal> — "
-"Hibernate 自动返回 <literal>CreditCardPayment</literal>（和它的子类，因为 它"
-"们也实现了接口 <literal>Payment</literal>）、<literal>CashPayment</literal> "
-"和 <literal>Chequepayment</literal> 的实例，但不返回 "
-"<literal>NonelectronicTransaction</literal> 的实例。"
+#, no-c-format
+msgid "Once again, <literal>Payment</literal> is not mentioned explicitly. If we execute a query against the <literal>Payment</literal> interface, for example <literal>from Payment</literal>, Hibernate automatically returns instances of <literal>CreditCardPayment</literal> (and its subclasses, since they also implement <literal>Payment</literal>), <literal>CashPayment</literal> and <literal>ChequePayment</literal>, but not instances of <literal>NonelectronicTransaction</literal>."
+msgstr "我们还是没有明确的提到 <literal>Payment</literal>。如果我们针对接口 <literal>Payment</literal> 执行查询 — 如 <literal>from Payment</literal> — Hibernate 自动返回 <literal>CreditCardPayment</literal>（和它的子类，因为 它们也实现了接口 <literal>Payment</literal>）、<literal>CashPayment</literal> 和 <literal>Chequepayment</literal> 的实例，但不返回 <literal>NonelectronicTransaction</literal> 的实例。 "
#. Tag: title
#, no-c-format
@@ -340,70 +195,59 @@
msgstr "限制"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"There are limitations to the \"implicit polymorphism\" approach to the table "
-"per concrete-class mapping strategy. There are somewhat less restrictive "
-"limitations to <literal><union-subclass></literal> mappings."
-msgstr ""
-"对“每个具体类映射一张表”（table per concrete-class）的映射策略而言，隐式多态"
-"的方式有一定的限制。而 <literal><union-subclass></literal> 映射的限制则"
-"没有那么严格。"
+#, no-c-format
+msgid "There are limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal><union-subclass></literal> mappings."
+msgstr "对“每个具体类映射一张表”（table per concrete-class）的映射策略而言，隐式多态的方式有一定的限制。而 <literal><union-subclass></literal> 映射的限制则没有那么严格。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The following list shows the limitations of table per concrete-class "
-"mappings, and of implicit polymorphism, in Hibernate."
-msgstr ""
-"下面表格中列出了在 Hibernte 中“每个具体类一张表”的策略和隐式多态的限制。"
+#, no-c-format
+msgid "The following list shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
+msgstr "下面表格中列出了在 Hibernte 中“每个具体类一张表”的策略和隐式多态的限制。 "
#. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
msgid "table per class-heirarchy"
-msgstr "每个类分层结构一张表"
+msgstr "每个类分层结构一张表 "
#. Tag: para
#, no-c-format
msgid "Polymorphic many-to-one: <code><many-to-one></code>"
-msgstr ""
+msgstr "多态性多对一：<code><many-to-one></code>"
#. Tag: para
#, no-c-format
msgid "Polymorphic one-to-one: <code><one-to-one></code>"
-msgstr ""
+msgstr "多态性一对一：<code><one-to-one></code>"
#. Tag: para
#, no-c-format
msgid "Polymorphic one-to-many: <code><one-to-many></code>"
-msgstr ""
+msgstr "多态性一对多：<code><one-to-many></code>"
#. Tag: para
#, no-c-format
msgid "Polymorphic many-to-many: <code><many-to-many></code>"
-msgstr ""
+msgstr "多态性多对多：<code><many-to-many></code>"
#. Tag: para
#, no-c-format
-msgid ""
-"Polymorphic <literal>load()</literal> or <literal>get()</literal>: <code>s."
-"get(Payment.class, id)</code>"
-msgstr ""
+msgid "Polymorphic <literal>load()</literal> or <literal>get()</literal>: <code>s.get(Payment.class, id)</code>"
+msgstr "多态性 <literal>load()</literal> 或 <literal>get()</literal>：<code>s.get(Payment.class, id)</code>"
#. Tag: para
#, no-c-format
msgid "Polymorphic queries: <code>from Payment p</code>"
-msgstr ""
+msgstr "多态性查询：<code>from Payment p</code>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Polymorphic joins: <code>from Order o join o.payment p</code>"
-msgstr "from Order o join o.payment p"
+msgstr "多态性 join：<code>from Order o join o.payment p</code>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Outer join fetching is supported."
-msgstr "外连接（Outer join）读取"
+msgstr "支持外连接（Outer join）读取。"
#. Tag: term
#, no-c-format
@@ -411,39 +255,29 @@
msgstr "每个具体类一张表（union-subclass）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Polymorphic one-to-many: <code><one-to-many></code> (for <code>inverse="
-"\"true\"</code> only)"
-msgstr ""
-"<literal><one-to-many></literal> (仅适用于 <literal>inverse=\"true\"</"
-"literal>)"
+#, no-c-format
+msgid "Polymorphic one-to-many: <code><one-to-many></code> (for <code>inverse=\"true\"</code> only)"
+msgstr "多态性一对多：<literal><one-to-many></literal> (仅适用于 <literal>inverse=\"true\"</literal>)"
#. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
msgid "table per concrete class (implicit polymorphism"
-msgstr "每个具体类一张表（隐式多态）"
+msgstr "每个具体类一张表（隐式多态） "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Polymorphic many-to-one: <code><any></code>"
-msgstr "多态多对一"
+msgstr "多态多对一：<code><any></code>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Polymorphic <literal>load()</literal> or <literal>get()</literal>: <code>s."
-"createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()</"
-"code>"
-msgstr ""
-"s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()"
+#, no-c-format
+msgid "Polymorphic <literal>load()</literal> or <literal>get()</literal>: <code>s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()</code>"
+msgstr "多态性 <literal>load()</literal> 或 <literal>get()</literal>：<code>s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()</code>"
#. Tag: para
#, no-c-format
-msgid ""
-"Polymorphic one-to-one, polymorphic one-to-many, polymorphic joins, and "
-"outer join fetching are not supported."
-msgstr ""
+msgid "Polymorphic one-to-one, polymorphic one-to-many, polymorphic joins, and outer join fetching are not supported."
+msgstr "多态性一对一、多态性一对多，不支持多态性 join 和 outer join fetching。"
#~ msgid "<para>table per subclass</para>"
#~ msgstr "<para>每个子类一张表</para>"
@@ -836,60 +670,42 @@
#~ " ...\n"
#~ " </joined-subclass>\n"
#~ "</class>"
-
#~ msgid "Features of inheritance mappings"
#~ msgstr "继承映射特性（Features of inheritance mappings）"
-
#~ msgid "Inheritance strategy"
#~ msgstr "继承策略（Inheritance strategy）"
-
#~ msgid "Polymorphic one-to-one"
#~ msgstr "多态一对一"
-
#~ msgid "Polymorphic one-to-many"
#~ msgstr "多态一对多"
-
#~ msgid "Polymorphic many-to-many"
#~ msgstr "多态多对多"
-
#~ msgid "Polymorphic <literal>load()/get()</literal>"
#~ msgstr "Polymorphic <literal>load()/get()</literal>"
-
#~ msgid "Polymorphic queries"
#~ msgstr "多态查询"
-
#~ msgid "Polymorphic joins"
#~ msgstr "多态连接（join）"
-
#~ msgid "<many-to-one>"
#~ msgstr "<many-to-one>"
-
#~ msgid "<one-to-one>"
#~ msgstr "<one-to-one>"
-
#~ msgid "<one-to-many>"
#~ msgstr "<one-to-many>"
-
#~ msgid "<many-to-many>"
#~ msgstr "<many-to-many>"
-
#~ msgid "s.get(Payment.class, id)"
#~ msgstr "s.get(Payment.class, id)"
-
#~ msgid "from Payment p"
#~ msgstr "from Payment p"
-
#~ msgid "supported"
#~ msgstr "支持"
-
#~ msgid "<entry>table per subclass</entry>"
#~ msgstr "<entry>每个子类一张表</entry>"
-
#~ msgid "<any>"
#~ msgstr "<any>"
-
#~ msgid "not supported"
#~ msgstr "不支持"
-
#~ msgid "<many-to-any>"
#~ msgstr "<many-to-any>"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/performance.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/performance.po 2009-12-07 10:21:17 UTC (rev 97494)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/performance.po 2009-12-07 11:14:45 UTC (rev 97495)
@@ -7,7 +7,7 @@
"Project-Id-Version: performance\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:26\n"
-"PO-Revision-Date: 2009-11-24 10:13+1000\n"
+"PO-Revision-Date: 2009-12-07 09:35+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -27,16 +27,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate uses a <emphasis>fetching strategy</emphasis> to retrieve "
-"associated objects if the application needs to navigate the association. "
-"Fetch strategies can be declared in the O/R mapping metadata, or over-ridden "
-"by a particular HQL or <literal>Criteria</literal> query."
-msgstr ""
-"当应用程序需要在（Hibernate实体对象图的）关联关系间进行导航的时候，Hibernate "
-"使用 <emphasis>抓取策略（fetching strategy）</emphasis> 获取关联对象。抓取策"
-"略可以在 O/R 映射的元数据中声明，也可以在特定的 HQL 或<literal>条件查询"
-"（Criteria Query）</literal>中重载声明。"
+msgid "Hibernate uses a <emphasis>fetching strategy</emphasis> to retrieve associated objects if the application needs to navigate the association. Fetch strategies can be declared in the O/R mapping metadata, or over-ridden by a particular HQL or <literal>Criteria</literal> query."
+msgstr "当应用程序需要在（Hibernate实体对象图的）关联关系间进行导航的时候，Hibernate 使用 <emphasis>抓取策略（fetching strategy）</emphasis> 获取关联对象。抓取策略可以在 O/R 映射的元数据中声明，也可以在特定的 HQL 或<literal>条件查询（Criteria Query）</literal>中重载声明。"
#. Tag: para
#, no-c-format
@@ -45,54 +37,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Join fetching</emphasis>: Hibernate retrieves the associated "
-"instance or collection in the same <literal>SELECT</literal>, using an "
-"<literal>OUTER JOIN</literal>."
-msgstr ""
-"<emphasis>连接抓取（Join fetching）</emphasis>：Hibernate 通过在 "
-"<literal>SELECT</literal> 语句使用 <literal>OUTER JOIN</literal>（外连接）来"
-"获得对象的关联实例或者关联集合。 "
+msgid "<emphasis>Join fetching</emphasis>: Hibernate retrieves the associated instance or collection in the same <literal>SELECT</literal>, using an <literal>OUTER JOIN</literal>."
+msgstr "<emphasis>连接抓取（Join fetching）</emphasis>：Hibernate 通过在 <literal>SELECT</literal> 语句使用 <literal>OUTER JOIN</literal>（外连接）来获得对象的关联实例或者关联集合。 "
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Select fetching</emphasis>: a second <literal>SELECT</literal> is "
-"used to retrieve the associated entity or collection. Unless you explicitly "
-"disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this "
-"second select will only be executed when you access the association."
-msgstr ""
-"<emphasis>查询抓取（Select fetching）</emphasis>：另外发送一条 "
-"<literal>SELECT</literal> 语句抓取当前对象的关联实体或集合。除非你显式的指定 "
-"<literal>lazy=\"false\"</literal> 禁止 延迟抓取（lazy fetching），否则只有当"
-"你真正访问关联关系的时候，才会执行第二条 select 语句。"
+msgid "<emphasis>Select fetching</emphasis>: a second <literal>SELECT</literal> is used to retrieve the associated entity or collection. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you access the association."
+msgstr "<emphasis>查询抓取（Select fetching）</emphasis>：另外发送一条 <literal>SELECT</literal> 语句抓取当前对象的关联实体或集合。除非你显式的指定 <literal>lazy=\"false\"</literal> 禁止 延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条 select 语句。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Subselect fetching</emphasis>: a second <literal>SELECT</literal> "
-"is used to retrieve the associated collections for all entities retrieved in "
-"a previous query or fetch. Unless you explicitly disable lazy fetching by "
-"specifying <literal>lazy=\"false\"</literal>, this second select will only "
-"be executed when you access the association."
-msgstr ""
-"<emphasis>子查询抓取（Subselect fetching）</emphasis>：另外发送一条 "
-"<literal>SELECT</literal> 语句抓取在前面查询到（或者抓取到）的所有实体对象的"
-"关联集合。除非你显式的指定 <literal>lazy=\"false\"</literal> 禁止延迟抓取"
-"（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条 select "
-"语句。"
+msgid "<emphasis>Subselect fetching</emphasis>: a second <literal>SELECT</literal> is used to retrieve the associated collections for all entities retrieved in a previous query or fetch. Unless you explicitly disable lazy fetching by specifying <literal>lazy=\"false\"</literal>, this second select will only be executed when you access the association."
+msgstr "<emphasis>子查询抓取（Subselect fetching）</emphasis>：另外发送一条 <literal>SELECT</literal> 语句抓取在前面查询到（或者抓取到）的所有实体对象的关联集合。除非你显式的指定 <literal>lazy=\"false\"</literal> 禁止延迟抓取（lazy fetching），否则只有当你真正访问关联关系的时候，才会执行第二条 select 语句。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Batch fetching</emphasis>: an optimization strategy for select "
-"fetching. Hibernate retrieves a batch of entity instances or collections in "
-"a single <literal>SELECT</literal> by specifying a list of primary or "
-"foreign keys."
-msgstr ""
-"<emphasis>批量抓取（Batch fetching）</emphasis>：对查询抓取的优化方案，通过指"
-"定一个主键或外键列表，Hibernate 使用单条 <literal>SELECT</literal> 语句获取一"
-"批对象实例或集合。"
+msgid "<emphasis>Batch fetching</emphasis>: an optimization strategy for select fetching. Hibernate retrieves a batch of entity instances or collections in a single <literal>SELECT</literal> by specifying a list of primary or foreign keys."
+msgstr "<emphasis>批量抓取（Batch fetching）</emphasis>：对查询抓取的优化方案，通过指定一个主键或外键列表，Hibernate 使用单条 <literal>SELECT</literal> 语句获取一批对象实例或集合。"
#. Tag: para
#, no-c-format
@@ -101,86 +62,38 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Immediate fetching</emphasis>: an association, collection or "
-"attribute is fetched immediately when the owner is loaded."
-msgstr ""
-"<emphasis>Immediate fetching，立即抓取</emphasis>：当宿主被加载时，关联、集合"
-"或属性被立即抓取。"
+msgid "<emphasis>Immediate fetching</emphasis>: an association, collection or attribute is fetched immediately when the owner is loaded."
+msgstr "<emphasis>Immediate fetching，立即抓取</emphasis>：当宿主被加载时，关联、集合或属性被立即抓取。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Lazy collection fetching</emphasis>: a collection is fetched when "
-"the application invokes an operation upon that collection. This is the "
-"default for collections."
-msgstr ""
-"<emphasis>Lazy collection fetching，延迟集合抓取</emphasis>：直到应用程序对集"
-"合进行了一次操作时，集合才被抓取（对集合而言这是默认行为）。"
+msgid "<emphasis>Lazy collection fetching</emphasis>: a collection is fetched when the application invokes an operation upon that collection. This is the default for collections."
+msgstr "<emphasis>Lazy collection fetching，延迟集合抓取</emphasis>：直到应用程序对集合进行了一次操作时，集合才被抓取（对集合而言这是默认行为）。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>\"Extra-lazy\" collection fetching</emphasis>: individual elements "
-"of the collection are accessed from the database as needed. Hibernate tries "
-"not to fetch the whole collection into memory unless absolutely needed. It "
-"is suitable for large collections."
-msgstr ""
-"<emphasis>\"Extra-lazy\" collection fetching,\"Extra-lazy\" 集合抓取</"
-"emphasis>：对集合类中的每个元素而言，都是直到需要时才去访问数据库。除非绝对必"
-"要，Hibernate 不会试图去把整个集合都抓取到内存里来（适用于非常大的集合）。"
+msgid "<emphasis>\"Extra-lazy\" collection fetching</emphasis>: individual elements of the collection are accessed from the database as needed. Hibernate tries not to fetch the whole collection into memory unless absolutely needed. It is suitable for large collections."
+msgstr "<emphasis>\"Extra-lazy\" collection fetching,\"Extra-lazy\" 集合抓取</emphasis>：对集合类中的每个元素而言，都是直到需要时才去访问数据库。除非绝对必要，Hibernate 不会试图去把整个集合都抓取到内存里来（适用于非常大的集合）。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Proxy fetching</emphasis>: a single-valued association is fetched "
-"when a method other than the identifier getter is invoked upon the "
-"associated object."
-msgstr ""
-"<emphasis>Proxy fetching，代理抓取</emphasis>：对返回单值的关联而言，当其某个"
-"方法被调用，而非对其关键字进行 get 操作时才抓取。"
+msgid "<emphasis>Proxy fetching</emphasis>: a single-valued association is fetched when a method other than the identifier getter is invoked upon the associated object."
+msgstr "<emphasis>Proxy fetching，代理抓取</emphasis>：对返回单值的关联而言，当其某个方法被调用，而非对其关键字进行 get 操作时才抓取。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>\"No-proxy\" fetching</emphasis>: a single-valued association is "
-"fetched when the instance variable is accessed. Compared to proxy fetching, "
-"this approach is less lazy; the association is fetched even when only the "
-"identifier is accessed. It is also more transparent, since no proxy is "
-"visible to the application. This approach requires buildtime bytecode "
-"instrumentation and is rarely necessary."
-msgstr ""
-"<emphasis>\"No-proxy\" fetching，非代理抓取</emphasis>：对返回单值的关联而"
-"言，当实例变量被访问的时候进行抓取。与上面的代理抓取相比，这种方法没有那么“延"
-"迟”得厉害（就算只访问标识符，也会导致关联抓取）但是更加透明，因为对应用程序来"
-"说，不再看到 proxy。这种方法需要在编译期间进行字节码增强操作，因此很少需要用"
-"到。"
+msgid "<emphasis>\"No-proxy\" fetching</emphasis>: a single-valued association is fetched when the instance variable is accessed. Compared to proxy fetching, this approach is less lazy; the association is fetched even when only the identifier is accessed. It is also more transparent, since no proxy is visible to the application. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>\"No-proxy\" fetching，非代理抓取</emphasis>：对返回单值的关联而言，当实例变量被访问的时候进行抓取。与上面的代理抓取相比，这种方法没有那么“延迟”得厉害（就算只访问标识符，也会导致关联抓取）但是更加透明，因为对应用程序来说，不再看到 proxy。这种方法需要在编译期间进行字节码增强操作，因此很少需要用到。"
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Lazy attribute fetching</emphasis>: an attribute or single valued "
-"association is fetched when the instance variable is accessed. This approach "
-"requires buildtime bytecode instrumentation and is rarely necessary."
-msgstr ""
-"<emphasis>Lazy attribute fetching，属性延迟加载</emphasis>：对属性或返回单值"
-"的关联而言，当其实例变量被访问的时候进行抓取。需要编译期字节码强化，因此这一"
-"方法很少是必要的。"
+msgid "<emphasis>Lazy attribute fetching</emphasis>: an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary."
+msgstr "<emphasis>Lazy attribute fetching，属性延迟加载</emphasis>：对属性或返回单值的关联而言，当其实例变量被访问的时候进行抓取。需要编译期字节码强化，因此这一方法很少是必要的。"
#. Tag: para
#, no-c-format
-msgid ""
-"We have two orthogonal notions here: <emphasis>when</emphasis> is the "
-"association fetched and <emphasis>how</emphasis> is it fetched. It is "
-"important that you do not confuse them. We use <literal>fetch</literal> to "
-"tune performance. We can use <literal>lazy</literal> to define a contract "
-"for what data is always available in any detached instance of a particular "
-"class."
-msgstr ""
-"这里有两个正交的概念：关联<emphasis>何时</emphasis>被抓取，以及被<emphasis>如"
-"何</emphasis>抓取（会采用什么样的 SQL 语句）。注意不要混淆它们。我们使用"
-"<literal>抓取</literal>来改善性能。我们使用<literal>延迟</literal>来定义一些"
-"契约，对某特定类的某个脱管的实例，知道有哪些数据是可以使用的。"
+msgid "We have two orthogonal notions here: <emphasis>when</emphasis> is the association fetched and <emphasis>how</emphasis> is it fetched. It is important that you do not confuse them. We use <literal>fetch</literal> to tune performance. We can use <literal>lazy</literal> to define a contract for what data is always available in any detached instance of a particular class."
+msgstr "这里有两个正交的概念：关联<emphasis>何时</emphasis>被抓取，以及被<emphasis>如何</emphasis>抓取（会采用什么样的 SQL 语句）。注意不要混淆它们。我们使用<literal>抓取</literal>来改善性能。我们使用<literal>延迟</literal>来定义一些契约，对某特定类的某个脱管的实例，知道有哪些数据是可以使用的。"
#. Tag: title
#, no-c-format
@@ -189,75 +102,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"By default, Hibernate3 uses lazy select fetching for collections and lazy "
-"proxy fetching for single-valued associations. These defaults make sense for "
-"most associations in the majority of applications."
-msgstr ""
-"默认情况下，Hibernate 3 对集合使用延迟 select 抓取，对返回单值的关联使用延迟"
-"代理抓取。对几乎是所有的应用而言，其绝大多数的关联，这种策略都是有效的。"
+msgid "By default, Hibernate3 uses lazy select fetching for collections and lazy proxy fetching for single-valued associations. These defaults make sense for most associations in the majority of applications."
+msgstr "默认情况下，Hibernate 3 对集合使用延迟 select 抓取，对返回单值的关联使用延迟代理抓取。对几乎是所有的应用而言，其绝大多数的关联，这种策略都是有效的。"
#. Tag: para
#, no-c-format
-msgid ""
-"If you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate "
-"will use the batch fetch optimization for lazy fetching. This optimization "
-"can also be enabled at a more granular level."
-msgstr ""
-"假若你设置了 <literal>hibernate.default_batch_fetch_size</literal>，"
-"Hibernate 会对延迟加载采取批量抓取优化措施（这种优化也可能会在更细化的级别打"
-"开）。"
+msgid "If you set <literal>hibernate.default_batch_fetch_size</literal>, Hibernate will use the batch fetch optimization for lazy fetching. This optimization can also be enabled at a more granular level."
+msgstr "假若你设置了 <literal>hibernate.default_batch_fetch_size</literal>，Hibernate 会对延迟加载采取批量抓取优化措施（这种优化也可能会在更细化的级别打开）。"
#. Tag: para
#, no-c-format
-msgid ""
-"Please be aware that access to a lazy association outside of the context of "
-"an open Hibernate session will result in an exception. For example:"
-msgstr ""
-"然而，你必须了解延迟抓取带来的一个问题。在一个打开的 Hibernate session 上下文"
-"之外调用延迟集合会导致一次意外。比如： "
+msgid "Please be aware that access to a lazy association outside of the context of an open Hibernate session will result in an exception. For example:"
+msgstr "然而，你必须了解延迟抓取带来的一个问题。在一个打开的 Hibernate session 上下文之外调用延迟集合会导致一次意外。比如： "
#. Tag: para
#, no-c-format
-msgid ""
-"Since the permissions collection was not initialized when the "
-"<literal>Session</literal> was closed, the collection will not be able to "
-"load its state. <emphasis>Hibernate does not support lazy initialization for "
-"detached objects</emphasis>. This can be fixed by moving the code that reads "
-"from the collection to just before the transaction is committed."
-msgstr ""
-"在 <literal>Session</literal> 关闭后，permessions 集合将是未实例化的、不再可"
-"用，因此无法正常载入其状态。 <emphasis>Hibernate 对脱管对象不支持延迟实例化</"
-"emphasis>。这里的修改方法是将 permissions 读取数据的代码移到事务提交之前。"
+msgid "Since the permissions collection was not initialized when the <literal>Session</literal> was closed, the collection will not be able to load its state. <emphasis>Hibernate does not support lazy initialization for detached objects</emphasis>. This can be fixed by moving the code that reads from the collection to just before the transaction is committed."
+msgstr "在 <literal>Session</literal> 关闭后，permessions 集合将是未实例化的、不再可用，因此无法正常载入其状态。 <emphasis>Hibernate 对脱管对象不支持延迟实例化</emphasis>。这里的修改方法是将 permissions 读取数据的代码移到事务提交之前。"
#. Tag: para
#, no-c-format
-msgid ""
-"Alternatively, you can use a non-lazy collection or association, by "
-"specifying <literal>lazy=\"false\"</literal> for the association mapping. "
-"However, it is intended that lazy initialization be used for almost all "
-"collections and associations. If you define too many non-lazy associations "
-"in your object model, Hibernate will fetch the entire database into memory "
-"in every transaction."
-msgstr ""
-"除此之外，通过对关联映射指定 <literal>lazy=\"false\"</literal>，我们也可以使"
-"用非延迟的集合或关联。但是，对绝大部分集合来说，更推荐使用延迟方式抓取数据。"
-"如果在你的对象模型中定义了太多的非延迟关联，Hibernate 最终几乎需要在每个事务"
-"中载入整个数据库到内存中。"
+msgid "Alternatively, you can use a non-lazy collection or association, by specifying <literal>lazy=\"false\"</literal> for the association mapping. However, it is intended that lazy initialization be used for almost all collections and associations. If you define too many non-lazy associations in your object model, Hibernate will fetch the entire database into memory in every transaction."
+msgstr "除此之外，通过对关联映射指定 <literal>lazy=\"false\"</literal>，我们也可以使用非延迟的集合或关联。但是，对绝大部分集合来说，更推荐使用延迟方式抓取数据。如果在你的对象模型中定义了太多的非延迟关联，Hibernate 最终几乎需要在每个事务中载入整个数据库到内存中。"
#. Tag: para
#, no-c-format
-msgid ""
-"On the other hand, you can use join fetching, which is non-lazy by nature, "
-"instead of select fetching in a particular transaction. We will now explain "
-"how to customize the fetching strategy. In Hibernate3, the mechanisms for "
-"choosing a fetch strategy are identical for single-valued associations and "
-"collections."
-msgstr ""
-"但是，另一方面，在一些特殊的事务中，我们也经常需要使用到连接抓取（它本身上就"
-"是非延迟的），以代替查询抓取。 下面我们将会很快明白如何具体的定制 Hibernate "
-"中的抓取策略。在 Hibernate3 中，具体选择哪种抓取策略的机制是和选择 单值关联或"
-"集合关联相一致的。 "
+msgid "On the other hand, you can use join fetching, which is non-lazy by nature, instead of select fetching in a particular transaction. We will now explain how to customize the fetching strategy. In Hibernate3, the mechanisms for choosing a fetch strategy are identical for single-valued associations and collections."
+msgstr "但是，另一方面，在一些特殊的事务中，我们也经常需要使用到连接抓取（它本身上就是非延迟的），以代替查询抓取。 下面我们将会很快明白如何具体的定制 Hibernate 中的抓取策略。在 Hibernate3 中，具体选择哪种抓取策略的机制是和选择 单值关联或集合关联相一致的。 "
#. Tag: title
#, no-c-format
@@ -266,26 +137,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Select fetching (the default) is extremely vulnerable to N+1 selects "
-"problems, so we might want to enable join fetching in the mapping document:"
-msgstr ""
-"查询抓取（默认的）在 N+1 查询的情况下是极其脆弱的，因此我们可能会要求在映射文"
-"档中定义使用连接抓取："
+msgid "Select fetching (the default) is extremely vulnerable to N+1 selects problems, so we might want to enable join fetching in the mapping document:"
+msgstr "查询抓取（默认的）在 N+1 查询的情况下是极其脆弱的，因此我们可能会要求在映射文档中定义使用连接抓取："
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>fetch</literal> strategy defined in the mapping document "
-"affects:"
-msgstr ""
-"在映射文档中定义的<literal>抓取</literal>策略将会对以下列表条目产生影响："
+msgid "The <literal>fetch</literal> strategy defined in the mapping document affects:"
+msgstr "在映射文档中定义的<literal>抓取</literal>策略将会对以下列表条目产生影响："
#. Tag: para
#, no-c-format
msgid "retrieval via <literal>get()</literal> or <literal>load()</literal>"
-msgstr ""
-"通过 <literal>get()</literal> 或 <literal>load()</literal> 方法取得数据。"
+msgstr "通过 <literal>get()</literal> 或 <literal>load()</literal> 方法取得数据。"
#. Tag: para
#, no-c-format
@@ -304,53 +167,27 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Irrespective of the fetching strategy you use, the defined non-lazy graph is "
-"guaranteed to be loaded into memory. This might, however, result in several "
-"immediate selects being used to execute a particular HQL query."
-msgstr ""
-"不管你使用哪种抓取策略，定义为非延迟的类图会被保证一定装载入内存。注意这可能"
-"意味着在一条 HQL 查询后紧跟着一系列的查询。 "
+msgid "Irrespective of the fetching strategy you use, the defined non-lazy graph is guaranteed to be loaded into memory. This might, however, result in several immediate selects being used to execute a particular HQL query."
+msgstr "不管你使用哪种抓取策略，定义为非延迟的类图会被保证一定装载入内存。注意这可能意味着在一条 HQL 查询后紧跟着一系列的查询。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Usually, the mapping document is not used to customize fetching. Instead, we "
-"keep the default behavior, and override it for a particular transaction, "
-"using <literal>left join fetch</literal> in HQL. This tells Hibernate to "
-"fetch the association eagerly in the first select, using an outer join. In "
-"the <literal>Criteria</literal> query API, you would use "
-"<literal>setFetchMode(FetchMode.JOIN)</literal>."
-msgstr ""
-"通常情况下，我们并不使用映射文档进行抓取策略的定制。更多的是，保持其默认值，"
-"然后在特定的事务中， 使用 HQL 的<literal>左连接抓取（left join fetch）</"
-"literal> 对其进行重载。这将通知 Hibernate在第一次查询中使用外部关联（outer "
-"join），直接得到其关联数据。在<literal>条件查询</literal> API 中，应该调用 "
-"<literal>setFetchMode（FetchMode.JOIN）</literal>语句。 "
+msgid "Usually, the mapping document is not used to customize fetching. Instead, we keep the default behavior, and override it for a particular transaction, using <literal>left join fetch</literal> in HQL. This tells Hibernate to fetch the association eagerly in the first select, using an outer join. In the <literal>Criteria</literal> query API, you would use <literal>setFetchMode(FetchMode.JOIN)</literal>."
+msgstr "通常情况下，我们并不使用映射文档进行抓取策略的定制。更多的是，保持其默认值，然后在特定的事务中， 使用 HQL 的<literal>左连接抓取（left join fetch）</literal> 对其进行重载。这将通知 Hibernate在第一次查询中使用外部关联（outer join），直接得到其关联数据。在<literal>条件查询</literal> API 中，应该调用 <literal>setFetchMode（FetchMode.JOIN）</literal>语句。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If you want to change the fetching strategy used by <literal>get()</literal> "
-"or <literal>load()</literal>, you can use a <literal>Criteria</literal> "
-"query. For example:"
-msgstr ""
-"也许你喜欢仅仅通过条件查询，就可以改变 <literal>get()</literal> 或 "
-"<literal>load()</literal> 语句中的数据抓取策略。例如： "
+msgid "If you want to change the fetching strategy used by <literal>get()</literal> or <literal>load()</literal>, you can use a <literal>Criteria</literal> query. For example:"
+msgstr "也许你喜欢仅仅通过条件查询，就可以改变 <literal>get()</literal> 或 <literal>load()</literal> 语句中的数据抓取策略。例如： "
#. Tag: para
#, no-c-format
-msgid ""
-"This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan"
-"\"."
-msgstr ""
-"这就是其他 ORM 解决方案的“抓取计划（fetch plan）”在 Hibernate 中的等价物。"
+msgid "This is Hibernate's equivalent of what some ORM solutions call a \"fetch plan\"."
+msgstr "这就是其他 ORM 解决方案的“抓取计划（fetch plan）”在 Hibernate 中的等价物。"
#. Tag: para
#, no-c-format
-msgid ""
-"A completely different approach to problems with N+1 selects is to use the "
-"second-level cache."
+msgid "A completely different approach to problems with N+1 selects is to use the second-level cache."
msgstr "截然不同的一种避免 N+1 次查询的方法是，使用二级缓存。 "
#. Tag: title
@@ -360,61 +197,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Lazy fetching for collections is implemented using Hibernate's own "
-"implementation of persistent collections. However, a different mechanism is "
-"needed for lazy behavior in single-ended associations. The target entity of "
-"the association must be proxied. Hibernate implements lazy initializing "
-"proxies for persistent objects using runtime bytecode enhancement which is "
-"accessed via the CGLIB library."
-msgstr ""
-"在 Hinerbate 中，对集合的延迟抓取的采用了自己的实现方法。但是，对于单端关联的"
-"延迟抓取，则需要采用 其他不同的机制。单端关联的目标实体必须使用代理，"
-"Hihernate 在运行期二进制级（通过优异的 CGLIB 库）， 为持久对象实现了延迟载入"
-"代理。 "
+msgid "Lazy fetching for collections is implemented using Hibernate's own implementation of persistent collections. However, a different mechanism is needed for lazy behavior in single-ended associations. The target entity of the association must be proxied. Hibernate implements lazy initializing proxies for persistent objects using runtime bytecode enhancement which is accessed via the CGLIB library."
+msgstr "在 Hinerbate 中，对集合的延迟抓取的采用了自己的实现方法。但是，对于单端关联的延迟抓取，则需要采用 其他不同的机制。单端关联的目标实体必须使用代理，Hihernate 在运行期二进制级（通过优异的 CGLIB 库）， 为持久对象实现了延迟载入代理。 "
#. Tag: para
#, no-c-format
-msgid ""
-"At startup, Hibernate3 generates proxies by default for all persistent "
-"classes and uses them to enable lazy fetching of <literal>many-to-one</"
-"literal> and <literal>one-to-one</literal> associations."
-msgstr ""
-"默认的，Hibernate3 将会为所有的持久对象产生代理（在启动阶段），然后使用他们实"
-"现 <literal>多对一（many-to-one）</literal>关联和<literal>一对一（one-to-"
-"one）</literal> 关联的延迟抓取。 "
+msgid "At startup, Hibernate3 generates proxies by default for all persistent classes and uses them to enable lazy fetching of <literal>many-to-one</literal> and <literal>one-to-one</literal> associations."
+msgstr "默认的，Hibernate3 将会为所有的持久对象产生代理（在启动阶段），然后使用他们实现 <literal>多对一（many-to-one）</literal>关联和<literal>一对一（one-to-one）</literal> 关联的延迟抓取。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The mapping file may declare an interface to use as the proxy interface for "
-"that class, with the <literal>proxy</literal> attribute. By default, "
-"Hibernate uses a subclass of the class. <emphasis>The proxied class must "
-"implement a default constructor with at least package visibility. This "
-"constructor is recommended for all persistent classes</emphasis>."
-msgstr ""
-"在映射文件中，可以通过设置 <literal>proxy</literal> 属性为目标 class 声明一个"
-"接口供代理接口使用。 默认的，Hibernate 将会使用该类的一个子类。<emphasis>注"
-"意：被代理的类必须实现一个至少包可见的默认构造函数，我们建议所有的持久类都应"
-"拥有这样的构造函数。</emphasis>"
+msgid "The mapping file may declare an interface to use as the proxy interface for that class, with the <literal>proxy</literal> attribute. By default, Hibernate uses a subclass of the class. <emphasis>The proxied class must implement a default constructor with at least package visibility. This constructor is recommended for all persistent classes</emphasis>."
+msgstr "在映射文件中，可以通过设置 <literal>proxy</literal> 属性为目标 class 声明一个接口供代理接口使用。 默认的，Hibernate 将会使用该类的一个子类。<emphasis>注意：被代理的类必须实现一个至少包可见的默认构造函数，我们建议所有的持久类都应拥有这样的构造函数。</emphasis>"
#. Tag: para
#, no-c-format
-msgid ""
-"There are potential problems to note when extending this approach to "
-"polymorphic classes.For example:"
+msgid "There are potential problems to note when extending this approach to polymorphic classes.For example:"
msgstr "在如此方式定义一个多态类的时候，有许多值得注意的常见性的问题，例如： "
#. Tag: para
#, no-c-format
-msgid ""
-"Firstly, instances of <literal>Cat</literal> will never be castable to "
-"<literal>DomesticCat</literal>, even if the underlying instance is an "
-"instance of <literal>DomesticCat</literal>:"
-msgstr ""
-"首先，<literal>Cat</literal> 实例永远不可以被强制转换为 "
-"<literal>DomesticCat</literal>，即使它本身就是 <literal>DomesticCat</"
-"literal> 实例。"
+msgid "Firstly, instances of <literal>Cat</literal> will never be castable to <literal>DomesticCat</literal>, even if the underlying instance is an instance of <literal>DomesticCat</literal>:"
+msgstr "首先，<literal>Cat</literal> 实例永远不可以被强制转换为 <literal>DomesticCat</literal>，即使它本身就是 <literal>DomesticCat</literal> 实例。"
#. Tag: para
#, no-c-format
@@ -423,61 +227,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"However, the situation is not quite as bad as it looks. Even though we now "
-"have two references to different proxy objects, the underlying instance will "
-"still be the same object:"
-msgstr ""
-"虽然如此，但实际情况并没有看上去那么糟糕。虽然我们现在有两个不同的引用，分别"
-"指向这两个不同的代理对象，但实际上，其底层应该是同一个实例对象："
+msgid "However, the situation is not quite as bad as it looks. Even though we now have two references to different proxy objects, the underlying instance will still be the same object:"
+msgstr "虽然如此，但实际情况并没有看上去那么糟糕。虽然我们现在有两个不同的引用，分别指向这两个不同的代理对象，但实际上，其底层应该是同一个实例对象："
#. Tag: para
#, no-c-format
-msgid ""
-"Third, you cannot use a CGLIB proxy for a <literal>final</literal> class or "
-"a class with any <literal>final</literal> methods."
-msgstr ""
-"第三，你不能对 <literal>final</literal> 类或具有 <literal>final</literal> 方"
-"法的类使用 CGLIB 代理。"
+msgid "Third, you cannot use a CGLIB proxy for a <literal>final</literal> class or a class with any <literal>final</literal> methods."
+msgstr "第三，你不能对 <literal>final</literal> 类或具有 <literal>final</literal> 方法的类使用 CGLIB 代理。"
#. Tag: para
#, no-c-format
-msgid ""
-"Finally, if your persistent object acquires any resources upon instantiation "
-"(e.g. in initializers or default constructor), then those resources will "
-"also be acquired by the proxy. The proxy class is an actual subclass of the "
-"persistent class."
-msgstr ""
-"最后，如果你的持久化对象在实例化时需要某些资源（例如，在实例化方法、默认构造"
-"方法中），那么代理对象也同样需要使用这些资源。实际上，代理类是持久化类的子"
-"类。"
+msgid "Finally, if your persistent object acquires any resources upon instantiation (e.g. in initializers or default constructor), then those resources will also be acquired by the proxy. The proxy class is an actual subclass of the persistent class."
+msgstr "最后，如果你的持久化对象在实例化时需要某些资源（例如，在实例化方法、默认构造方法中），那么代理对象也同样需要使用这些资源。实际上，代理类是持久化类的子类。"
#. Tag: para
#, no-c-format
-msgid ""
-"These problems are all due to fundamental limitations in Java's single "
-"inheritance model. To avoid these problems your persistent classes must each "
-"implement an interface that declares its business methods. You should "
-"specify these interfaces in the mapping file where <literal>CatImpl</"
-"literal> implements the interface <literal>Cat</literal> and "
-"<literal>DomesticCatImpl</literal> implements the interface "
-"<literal>DomesticCat</literal>. For example:"
-msgstr ""
-"这些问题都源于 Java 的单根继承模型的天生限制。如果你希望避免这些问题，那么你"
-"的每个持久化类必须实现一个接口， 在此接口中已经声明了其业务方法。然后，你需要"
-"在映射文档中再指定这些接口，如 <literal>CatImpl</literal> 实现 <literal>Cat</"
-"literal> 而 <literal>DomesticCatImpl</literal> 实现 <literal>DomesticCat</"
-"literal> 接口。例如："
+msgid "These problems are all due to fundamental limitations in Java's single inheritance model. To avoid these problems your persistent classes must each implement an interface that declares its business methods. You should specify these interfaces in the mapping file where <literal>CatImpl</literal> implements the interface <literal>Cat</literal> and <literal>DomesticCatImpl</literal> implements the interface <literal>DomesticCat</literal>. For example:"
+msgstr "这些问题都源于 Java 的单根继承模型的天生限制。如果你希望避免这些问题，那么你的每个持久化类必须实现一个接口， 在此接口中已经声明了其业务方法。然后，你需要在映射文档中再指定这些接口，如 <literal>CatImpl</literal> 实现 <literal>Cat</literal> 而 <literal>DomesticCatImpl</literal> 实现 <literal>DomesticCat</literal> 接口。例如："
#. Tag: para
#, no-c-format
-msgid ""
-"Then proxies for instances of <literal>Cat</literal> and "
-"<literal>DomesticCat</literal> can be returned by <literal>load()</literal> "
-"or <literal>iterate()</literal>."
-msgstr ""
-"然后，<literal>load()</literal> 和 <literal>iterate()</literal> 永远也不会返"
-"回 <literal>Cat</literal> 和 <literal>DomesticCat</literal> 实例的代理。"
+msgid "Then proxies for instances of <literal>Cat</literal> and <literal>DomesticCat</literal> can be returned by <literal>load()</literal> or <literal>iterate()</literal>."
+msgstr "然后，<literal>load()</literal> 和 <literal>iterate()</literal> 永远也不会返回 <literal>Cat</literal> 和 <literal>DomesticCat</literal> 实例的代理。"
#. Tag: title
#, no-c-format
@@ -491,37 +262,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Relationships are also lazily initialized. This means you must declare any "
-"properties to be of type <literal>Cat</literal>, not <literal>CatImpl</"
-"literal>."
-msgstr ""
-"这里，对象之间的关系也将被延迟载入。这就意味着，你应该将属性声明为 "
-"<literal>Cat</literal>，而不是 <literal>CatImpl</literal>。"
+msgid "Relationships are also lazily initialized. This means you must declare any properties to be of type <literal>Cat</literal>, not <literal>CatImpl</literal>."
+msgstr "这里，对象之间的关系也将被延迟载入。这就意味着，你应该将属性声明为 <literal>Cat</literal>，而不是 <literal>CatImpl</literal>。"
#. Tag: para
#, no-c-format
-msgid ""
-"Certain operations do <emphasis>not</emphasis> require proxy initialization:"
+msgid "Certain operations do <emphasis>not</emphasis> require proxy initialization:"
msgstr "有些方法中是<emphasis>不</emphasis>需要代理初始化的："
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>equals()</literal>: if the persistent class does not override "
-"<literal>equals()</literal>"
-msgstr ""
-"<literal>equals()</literal> 方法，如果持久类没有重载 <literal>equals()</"
-"literal> 方法。"
+msgid "<literal>equals()</literal>: if the persistent class does not override <literal>equals()</literal>"
+msgstr "<literal>equals()</literal> 方法，如果持久类没有重载 <literal>equals()</literal> 方法。"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>hashCode()</literal>: if the persistent class does not override "
-"<literal>hashCode()</literal>"
-msgstr ""
-"<literal>hashCode()</literal>：如果持久类没有重载 <literal>hashCode()</"
-"literal> 方法。"
+msgid "<literal>hashCode()</literal>: if the persistent class does not override <literal>hashCode()</literal>"
+msgstr "<literal>hashCode()</literal>：如果持久类没有重载 <literal>hashCode()</literal> 方法。"
#. Tag: para
#, no-c-format
@@ -530,24 +287,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate will detect persistent classes that override <literal>equals()</"
-"literal> or <literal>hashCode()</literal>."
-msgstr ""
-"Hibernate 将会识别出那些重载了 <literal>equals()</literal>、或 "
-"<literal>hashCode()</literal> 方法的持久化类。"
+msgid "Hibernate will detect persistent classes that override <literal>equals()</literal> or <literal>hashCode()</literal>."
+msgstr "Hibernate 将会识别出那些重载了 <literal>equals()</literal>、或 <literal>hashCode()</literal> 方法的持久化类。"
#. Tag: para
#, no-c-format
-msgid ""
-"By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default "
-"<literal>lazy=\"proxy\"</literal>, you can avoid problems associated with "
-"typecasting. However, buildtime bytecode instrumentation is required, and "
-"all operations will result in immediate proxy initialization."
-msgstr ""
-"若选择 <literal>lazy=\"no-proxy\"</literal> 而非默认的 <literal>lazy=\"proxy"
-"\"</literal>，我们可以避免类型转换带来的问题。然而，这样我们就需要编译期字节"
-"码增强，并且所有的操作都会导致立刻进行代理初始化。 "
+msgid "By choosing <literal>lazy=\"no-proxy\"</literal> instead of the default <literal>lazy=\"proxy\"</literal>, you can avoid problems associated with typecasting. However, buildtime bytecode instrumentation is required, and all operations will result in immediate proxy initialization."
+msgstr "若选择 <literal>lazy=\"no-proxy\"</literal> 而非默认的 <literal>lazy=\"proxy\"</literal>，我们可以避免类型转换带来的问题。然而，这样我们就需要编译期字节码增强，并且所有的操作都会导致立刻进行代理初始化。 "
#. Tag: title
#, no-c-format
@@ -556,149 +302,53 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A <literal>LazyInitializationException</literal> will be thrown by Hibernate "
-"if an uninitialized collection or proxy is accessed outside of the scope of "
-"the <literal>Session</literal>, i.e., when the entity owning the collection "
-"or having the reference to the proxy is in the detached state."
-msgstr ""
-"在 <literal>Session</literal> 范围之外访问未初始化的集合或代理，Hibernate 将"
-"会抛出 <literal>LazyInitializationException</literal> 异常。也就是说，在分离"
-"状态下，访问一个实体所拥有的集合，或者访问其指向代理的属性时，会引发此异常。 "
+msgid "A <literal>LazyInitializationException</literal> will be thrown by Hibernate if an uninitialized collection or proxy is accessed outside of the scope of the <literal>Session</literal>, i.e., when the entity owning the collection or having the reference to the proxy is in the detached state."
+msgstr "在 <literal>Session</literal> 范围之外访问未初始化的集合或代理，Hibernate 将会抛出 <literal>LazyInitializationException</literal> 异常。也就是说，在分离状态下，访问一个实体所拥有的集合，或者访问其指向代理的属性时，会引发此异常。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Sometimes a proxy or collection needs to be initialized before closing the "
-"<literal>Session</literal>. You can force initialization by calling "
-"<literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</"
-"literal>, for example. However, this can be confusing to readers of the code "
-"and it is not convenient for generic code."
-msgstr ""
-"有时候我们需要保证某个代理或者集合在 Session 关闭前就已经被初始化了。当然，我"
-"们可以通过强行调用 <literal>cat.getSex()</literal> 或者 <literal>cat."
-"getKittens().size()</literal> 之类的方法来确保这一点。 但是这样的程序会造成读"
-"者的疑惑，也不符合通常的代码规范。 "
+msgid "Sometimes a proxy or collection needs to be initialized before closing the <literal>Session</literal>. You can force initialization by calling <literal>cat.getSex()</literal> or <literal>cat.getKittens().size()</literal>, for example. However, this can be confusing to readers of the code and it is not convenient for generic code."
+msgstr "有时候我们需要保证某个代理或者集合在 Session 关闭前就已经被初始化了。当然，我们可以通过强行调用 <literal>cat.getSex()</literal> 或者 <literal>cat.getKittens().size()</literal> 之类的方法来确保这一点。 但是这样的程序会造成读者的疑惑，也不符合通常的代码规范。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The static methods <literal>Hibernate.initialize()</literal> and "
-"<literal>Hibernate.isInitialized()</literal>, provide the application with a "
-"convenient way of working with lazily initialized collections or proxies. "
-"<literal>Hibernate.initialize(cat)</literal> will force the initialization "
-"of a proxy, <literal>cat</literal>, as long as its <literal>Session</"
-"literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</"
-"literal> has a similar effect for the collection of kittens."
-msgstr ""
-"静态方法 <literal>Hibernate.initialized()</literal> 为你的应用程序提供了一个"
-"便捷的途径来延迟加载集合或代理。 只要它的 Session 处于 open 状态，"
-"<literal>Hibernate.initialize(cat)</literal> 将会为 cat 强制对代理实例化。同"
-"样，<literal>Hibernate.initialize(cat.getKittens())</literal> 对 kittens 的集"
-"合具有同样的功能。 "
+msgid "The static methods <literal>Hibernate.initialize()</literal> and <literal>Hibernate.isInitialized()</literal>, provide the application with a convenient way of working with lazily initialized collections or proxies. <literal>Hibernate.initialize(cat)</literal> will force the initialization of a proxy, <literal>cat</literal>, as long as its <literal>Session</literal> is still open. <literal>Hibernate.initialize( cat.getKittens() )</literal> has a similar effect for the collection of kittens."
+msgstr "静态方法 <literal>Hibernate.initialized()</literal> 为你的应用程序提供了一个便捷的途径来延迟加载集合或代理。 只要它的 Session 处于 open 状态，<literal>Hibernate.initialize(cat)</literal> 将会为 cat 强制对代理实例化。同样，<literal>Hibernate.initialize(cat.getKittens())</literal> 对 kittens 的集合具有同样的功能。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Another option is to keep the <literal>Session</literal> open until all "
-"required collections and proxies have been loaded. In some application "
-"architectures, particularly where the code that accesses data using "
-"Hibernate, and the code that uses it are in different application layers or "
-"different physical processes, it can be a problem to ensure that the "
-"<literal>Session</literal> is open when a collection is initialized. There "
-"are two basic ways to deal with this issue:"
-msgstr ""
-"还有另外一种选择，就是保持 <literal>Session</literal> 一直处于 open 状态，直"
-"到所有需要的集合或代理都被载入。 在某些应用架构中，特别是对于那些使用 "
-"Hibernate 进行数据访问的代码，以及那些在不同应用层和不同物理进程中使用 "
-"Hibernate 的代码。 在集合实例化时，如何保证 <literal>Session</literal> 处于 "
-"open 状态经常会是一个问题。有两种方法可以解决此问题： "
+msgid "Another option is to keep the <literal>Session</literal> open until all required collections and proxies have been loaded. In some application architectures, particularly where the code that accesses data using Hibernate, and the code that uses it are in different application layers or different physical processes, it can be a problem to ensure that the <literal>Session</literal> is open when a collection is initialized. There are two basic ways to deal with this issue:"
+msgstr "还有另外一种选择，就是保持 <literal>Session</literal> 一直处于 open 状态，直到所有需要的集合或代理都被载入。 在某些应用架构中，特别是对于那些使用 Hibernate 进行数据访问的代码，以及那些在不同应用层和不同物理进程中使用 Hibernate 的代码。 在集合实例化时，如何保证 <literal>Session</literal> 处于 open 状态经常会是一个问题。有两种方法可以解决此问题： "
#. Tag: para
#, no-c-format
-msgid ""
-"In a web-based application, a servlet filter can be used to close the "
-"<literal>Session</literal> only at the end of a user request, once the "
-"rendering of the view is complete (the <emphasis>Open Session in View</"
-"emphasis> pattern). Of course, this places heavy demands on the correctness "
-"of the exception handling of your application infrastructure. It is vitally "
-"important that the <literal>Session</literal> is closed and the transaction "
-"ended before returning to the user, even when an exception occurs during "
-"rendering of the view. See the Hibernate Wiki for examples of this \"Open "
-"Session in View\" pattern."
-msgstr ""
-"在一个基于 Web 的应用中，可以利用 servlet 过滤器（filter），在用户请求"
-"（request）结束、页面生成 结束时关闭 <literal>Session</literal>（这里使用了"
-"<emphasis>在展示层保持打开 Session 模式（Open Session in View）</"
-"emphasis>），当然，这将依赖于应用框架中异常需要被正确的处理。在返回界面给用户"
-"之前，乃至在生成界面过程中发生异常的情况下，正确关闭 <literal>Session</"
-"literal> 和结束事务将是非常重要的， 请参见 Hibernate wiki 上的 \"Open "
-"Session in View\" 模式，你可以找到示例。 "
+msgid "In a web-based application, a servlet filter can be used to close the <literal>Session</literal> only at the end of a user request, once the rendering of the view is complete (the <emphasis>Open Session in View</emphasis> pattern). Of course, this places heavy demands on the correctness of the exception handling of your application infrastructure. It is vitally important that the <literal>Session</literal> is closed and the transaction ended before returning to the user, even when an exception occurs during rendering of the view. See the Hibernate Wiki for examples of this \"Open Session in View\" pattern."
+msgstr "在一个基于 Web 的应用中，可以利用 servlet 过滤器（filter），在用户请求（request）结束、页面生成 结束时关闭 <literal>Session</literal>（这里使用了<emphasis>在展示层保持打开 Session 模式（Open Session in View）</emphasis>），当然，这将依赖于应用框架中异常需要被正确的处理。在返回界面给用户之前，乃至在生成界面过程中发生异常的情况下，正确关闭 <literal>Session</literal> 和结束事务将是非常重要的， 请参见 Hibernate wiki 上的 \"Open Session in View\" 模式，你可以找到示例。 "
#. Tag: para
#, no-c-format
-msgid ""
-"In an application with a separate business tier, the business logic must "
-"\"prepare\" all collections that the web tier needs before returning. This "
-"means that the business tier should load all the data and return all the "
-"data already initialized to the presentation/web tier that is required for a "
-"particular use case. Usually, the application calls <literal>Hibernate."
-"initialize()</literal> for each collection that will be needed in the web "
-"tier (this call must occur before the session is closed) or retrieves the "
-"collection eagerly using a Hibernate query with a <literal>FETCH</literal> "
-"clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</"
-"literal>. This is usually easier if you adopt the <emphasis>Command</"
-"emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
-msgstr ""
-"在一个拥有单独业务层的应用中，业务层必须在返回之前，为 web 层“准备”好其所需的"
-"数据集合。这就意味着 业务层应该载入所有表现层/web 层所需的数据，并将这些已实"
-"例化完毕的数据返回。通常，应用程序应该为 web 层所需的每个集合调用 "
-"<literal>Hibernate.initialize()</literal>（这个调用必须发生咱 session 关闭之"
-"前）；或者使用带有 <literal>FETCH</literal> 从句，或 <literal>FetchMode."
-"JOIN</literal> 的 Hibernate 查询，事先取得所有的数据集合。如果你在应用中使用"
-"了 <emphasis>Command</emphasis> 模式，代替 <emphasis>Session Facade</"
-"emphasis>，那么这项任务将会变得简单的多。 "
+msgid "In an application with a separate business tier, the business logic must \"prepare\" all collections that the web tier needs before returning. This means that the business tier should load all the data and return all the data already initialized to the presentation/web tier that is required for a particular use case. Usually, the application calls <literal>Hibernate.initialize()</literal> for each collection that will be needed in the web tier (this call must occur before the session is closed) or retrieves the collection eagerly using a Hibernate query with a <literal>FETCH</literal> clause or a <literal>FetchMode.JOIN</literal> in <literal>Criteria</literal>. This is usually easier if you adopt the <emphasis>Command</emphasis> pattern instead of a <emphasis>Session Facade</emphasis>."
+msgstr "在一个拥有单独业务层的应用中，业务层必须在返回之前，为 web 层“准备”好其所需的数据集合。这就意味着 业务层应该载入所有表现层/web 层所需的数据，并将这些已实例化完毕的数据返回。通常，应用程序应该为 web 层所需的每个集合调用 <literal>Hibernate.initialize()</literal>（这个调用必须发生咱 session 关闭之前）；或者使用带有 <literal>FETCH</literal> 从句，或 <literal>FetchMode.JOIN</literal> 的 Hibernate 查询，事先取得所有的数据集合。如果你在应用中使用了 <emphasis>Command</emphasis> 模式，代替 <emphasis>Session Facade</emphasis>，那么这项任务将会变得简单的多。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You can also attach a previously loaded object to a new <literal>Session</"
-"literal> with <literal>merge()</literal> or <literal>lock()</literal> before "
-"accessing uninitialized collections or other proxies. Hibernate does not, "
-"and certainly <emphasis>should</emphasis> not, do this automatically since "
-"it would introduce impromptu transaction semantics."
-msgstr ""
-"你也可以通过 <literal>merge()</literal> 或 <literal>lock()</literal> 方法，在"
-"访问未实例化的集合（或代理）之前，为先前载入的对象绑定一个新的 "
-"<literal>Session</literal>。显然，Hibernate 将不会，也不<emphasis>应该</"
-"emphasis>自动完成这些任务，因为这将引入一个特殊的事务语义。 "
+msgid "You can also attach a previously loaded object to a new <literal>Session</literal> with <literal>merge()</literal> or <literal>lock()</literal> before accessing uninitialized collections or other proxies. Hibernate does not, and certainly <emphasis>should</emphasis> not, do this automatically since it would introduce impromptu transaction semantics."
+msgstr "你也可以通过 <literal>merge()</literal> 或 <literal>lock()</literal> 方法，在访问未实例化的集合（或代理）之前，为先前载入的对象绑定一个新的 <literal>Session</literal>。显然，Hibernate 将不会，也不<emphasis>应该</emphasis>自动完成这些任务，因为这将引入一个特殊的事务语义。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Sometimes you do not want to initialize a large collection, but still need "
-"some information about it, like its size, for example, or a subset of the "
-"data."
-msgstr ""
-"有时候，你并不需要完全实例化整个大的集合，仅需要了解它的部分信息（例如其大"
-"小）、或者集合的部分内容。 "
+msgid "Sometimes you do not want to initialize a large collection, but still need some information about it, like its size, for example, or a subset of the data."
+msgstr "有时候，你并不需要完全实例化整个大的集合，仅需要了解它的部分信息（例如其大小）、或者集合的部分内容。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You can use a collection filter to get the size of a collection without "
-"initializing it:"
+msgid "You can use a collection filter to get the size of a collection without initializing it:"
msgstr "你可以使用集合过滤器得到其集合的大小，而不必实例化整个集合："
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>createFilter()</literal> method is also used to efficiently "
-"retrieve subsets of a collection without needing to initialize the whole "
-"collection:"
-msgstr ""
-"这里的 <literal>createFilter()</literal> 方法也可以被用来有效的抓取集合的部分"
-"内容，而无需实例化整个集合："
+msgid "The <literal>createFilter()</literal> method is also used to efficiently retrieve subsets of a collection without needing to initialize the whole collection:"
+msgstr "这里的 <literal>createFilter()</literal> 方法也可以被用来有效的抓取集合的部分内容，而无需实例化整个集合："
#. Tag: title
#, no-c-format
@@ -707,90 +357,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Using batch fetching, Hibernate can load several uninitialized proxies if "
-"one proxy is accessed. Batch fetching is an optimization of the lazy select "
-"fetching strategy. There are two ways you can configure batch fetching: on "
-"the class level and the collection level."
-msgstr ""
-"Hibernate 可以充分有效的使用批量抓取，也就是说，如果仅一个访问代理（或集"
-"合），那么 Hibernate 将不载入其他未实例化的代理。批量抓取是延迟查询抓取的优化"
-"方案，你可以在两种批量抓取方案之间进行选择：在类级别和集合级别。 "
+msgid "Using batch fetching, Hibernate can load several uninitialized proxies if one proxy is accessed. Batch fetching is an optimization of the lazy select fetching strategy. There are two ways you can configure batch fetching: on the class level and the collection level."
+msgstr "Hibernate 可以充分有效的使用批量抓取，也就是说，如果仅一个访问代理（或集合），那么 Hibernate 将不载入其他未实例化的代理。批量抓取是延迟查询抓取的优化方案，你可以在两种批量抓取方案之间进行选择：在类级别和集合级别。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Batch fetching for classes/entities is easier to understand. Consider the "
-"following example: at runtime you have 25 <literal>Cat</literal> instances "
-"loaded in a <literal>Session</literal>, and each <literal>Cat</literal> has "
-"a reference to its <literal>owner</literal>, a <literal>Person</literal>. "
-"The <literal>Person</literal> class is mapped with a proxy, <literal>lazy="
-"\"true\"</literal>. If you now iterate through all cats and call "
-"<literal>getOwner()</literal> on each, Hibernate will, by default, execute "
-"25 <literal>SELECT</literal> statements to retrieve the proxied owners. You "
-"can tune this behavior by specifying a <literal>batch-size</literal> in the "
-"mapping of <literal>Person</literal>:"
-msgstr ""
-"类/实体级别的批量抓取很容易理解。假设你在运行时将需要面对下面的问题：你在一"
-"个 <literal>Session</literal> 中载入了 25 个 <literal>Cat</literal> 实例，每"
-"个 <literal>Cat</literal> 实例都拥有一个引用成员 <literal>owner</literal>，其"
-"指向 <literal>Person</literal>，而 <literal>Person</literal> 类是代理，同时 "
-"<literal>lazy=\"true\"</literal>。如果你必须遍历整个 cats 集合，对每个元素调"
-"用 <literal>getOwner()</literal> 方法，Hibernate 将会默认的执行 25 次 "
-"<literal>SELECT</literal> 查询， 得到其 owner 的代理对象。这时，你可以通过在"
-"映射文件的 <literal>Person</literal> 属性，显式声明 <literal>batch-size</"
-"literal>，改变其行为： "
+msgid "Batch fetching for classes/entities is easier to understand. Consider the following example: at runtime you have 25 <literal>Cat</literal> instances loaded in a <literal>Session</literal>, and each <literal>Cat</literal> has a reference to its <literal>owner</literal>, a <literal>Person</literal>. The <literal>Person</literal> class is mapped with a proxy, <literal>lazy=\"true\"</literal>. If you now iterate through all cats and call <literal>getOwner()</literal> on each, Hibernate will, by default, execute 25 <literal>SELECT</literal> statements to retrieve the proxied owners. You can tune this behavior by specifying a <literal>batch-size</literal> in the mapping of <literal>Person</literal>:"
+msgstr "类/实体级别的批量抓取很容易理解。假设你在运行时将需要面对下面的问题：你在一个 <literal>Session</literal> 中载入了 25 个 <literal>Cat</literal> 实例，每个 <literal>Cat</literal> 实例都拥有一个引用成员 <literal>owner</literal>，其指向 <literal>Person</literal>，而 <literal>Person</literal> 类是代理，同时 <literal>lazy=\"true\"</literal>。如果你必须遍历整个 cats 集合，对每个元素调用 <literal>getOwner()</literal> 方法，Hibernate 将会默认的执行 25 次 <literal>SELECT</literal> 查询， 得到其 owner 的代理对象。这时，你可以通过在映射文件的 <literal>Person</literal> 属性，显式声明 <literal>batch-size</literal>，改变其行为： "
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate will now execute only three queries: the pattern is 10, 10, 5."
+msgid "Hibernate will now execute only three queries: the pattern is 10, 10, 5."
msgstr "随之，Hibernate 将只需要执行三次查询，分别为 10、10、 5。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You can also enable batch fetching of collections. For example, if each "
-"<literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, "
-"and 10 persons are currently loaded in the <literal>Session</literal>, "
-"iterating through all persons will generate 10 <literal>SELECT</literal>s, "
-"one for every call to <literal>getCats()</literal>. If you enable batch "
-"fetching for the <literal>cats</literal> collection in the mapping of "
-"<literal>Person</literal>, Hibernate can pre-fetch collections:"
-msgstr ""
-"你也可以在集合级别定义批量抓取。例如，如果每个 <literal>Person</literal> 都拥"
-"有一个延迟载入的 <literal>Cats</literal> 集合， 现在，<literal>Sesssion</"
-"literal> 中载入了 10 个 person 对象，遍历 person 集合将会引起 10 次 "
-"<literal>SELECT</literal> 查询，每次查询都会调用 <literal>getCats()</"
-"literal> 方法。如果你在 <literal>Person</literal> 的映射定义部分，允许对 "
-"<literal>cats</literal> 批量抓取，那么，Hibernate 将可以预先抓取整个集合。请"
-"看例子： "
+msgid "You can also enable batch fetching of collections. For example, if each <literal>Person</literal> has a lazy collection of <literal>Cat</literal>s, and 10 persons are currently loaded in the <literal>Session</literal>, iterating through all persons will generate 10 <literal>SELECT</literal>s, one for every call to <literal>getCats()</literal>. If you enable batch fetching for the <literal>cats</literal> collection in the mapping of <literal>Person</literal>, Hibernate can pre-fetch collections:"
+msgstr "你也可以在集合级别定义批量抓取。例如，如果每个 <literal>Person</literal> 都拥有一个延迟载入的 <literal>Cats</literal> 集合， 现在，<literal>Sesssion</literal> 中载入了 10 个 person 对象，遍历 person 集合将会引起 10 次 <literal>SELECT</literal> 查询，每次查询都会调用 <literal>getCats()</literal> 方法。如果你在 <literal>Person</literal> 的映射定义部分，允许对 <literal>cats</literal> 批量抓取，那么，Hibernate 将可以预先抓取整个集合。请看例子： "
#. Tag: para
#, no-c-format
-msgid ""
-"With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 "
-"collections in four <literal>SELECT</literal>s. Again, the value of the "
-"attribute depends on the expected number of uninitialized collections in a "
-"particular <literal>Session</literal>."
-msgstr ""
-"如果整个的 <literal>batch-size</literal> 是 3，那么 Hibernate 将会分四次执行 "
-"<literal>SELECT</literal> 查询， 按照 3、3、3、1 的大小分别载入数据。这里的每"
-"次载入的数据量还具体依赖于当前 <literal>Session</literal> 中未实例化集合的个"
-"数。 "
+msgid "With a <literal>batch-size</literal> of 3, Hibernate will load 3, 3, 3, 1 collections in four <literal>SELECT</literal>s. Again, the value of the attribute depends on the expected number of uninitialized collections in a particular <literal>Session</literal>."
+msgstr "如果整个的 <literal>batch-size</literal> 是 3，那么 Hibernate 将会分四次执行 <literal>SELECT</literal> 查询， 按照 3、3、3、1 的大小分别载入数据。这里的每次载入的数据量还具体依赖于当前 <literal>Session</literal> 中未实例化集合的个数。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Batch fetching of collections is particularly useful if you have a nested "
-"tree of items, i.e. the typical bill-of-materials pattern. However, a "
-"<emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> "
-"might be a better option for read-mostly trees."
-msgstr ""
-"如果你的模型中有嵌套的树状结构，例如典型的帐单－原料结构（bill-of-materials "
-"pattern），集合的批量抓取是非常有用的。（尽管在更多情况下对树进行读取时，"
-"<emphasis>嵌套集合（nested set）</emphasis>或<emphasis>原料路径"
-"（materialized path）</emphasis>可能是更好的解决方法。）"
+msgid "Batch fetching of collections is particularly useful if you have a nested tree of items, i.e. the typical bill-of-materials pattern. However, a <emphasis>nested set</emphasis> or a <emphasis>materialized path</emphasis> might be a better option for read-mostly trees."
+msgstr "如果你的模型中有嵌套的树状结构，例如典型的帐单－原料结构（bill-of-materials pattern），集合的批量抓取是非常有用的。（尽管在更多情况下对树进行读取时，<emphasis>嵌套集合（nested set）</emphasis>或<emphasis>原料路径（materialized path）</emphasis>可能是更好的解决方法。）"
#. Tag: title
#, no-c-format
@@ -799,14 +392,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If one lazy collection or single-valued proxy has to be fetched, Hibernate "
-"will load all of them, re-running the original query in a subselect. This "
-"works in the same way as batch-fetching but without the piecemeal loading."
-msgstr ""
-"假若一个延迟集合或单值代理需要抓取，Hibernate 会使用一个 subselect 重新运行原"
-"来的查询，一次性读入所有的实例。这和批量抓取的实现方法是一样的，不会有破碎的"
-"加载。 "
+msgid "If one lazy collection or single-valued proxy has to be fetched, Hibernate will load all of them, re-running the original query in a subselect. This works in the same way as batch-fetching but without the piecemeal loading."
+msgstr "假若一个延迟集合或单值代理需要抓取，Hibernate 会使用一个 subselect 重新运行原来的查询，一次性读入所有的实例。这和批量抓取的实现方法是一样的，不会有破碎的加载。 "
#. Tag: title
#, no-c-format
@@ -815,39 +402,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate3 supports the lazy fetching of individual properties. This "
-"optimization technique is also known as <emphasis>fetch groups</emphasis>. "
-"Please note that this is mostly a marketing feature; optimizing row reads is "
-"much more important than optimization of column reads. However, only loading "
-"some properties of a class could be useful in extreme cases. For example, "
-"when legacy tables have hundreds of columns and the data model cannot be "
-"improved."
-msgstr ""
-"Hibernate3 对单独的属性支持延迟抓取，这项优化技术也被称为<emphasis>组抓取"
-"（fetch groups）</emphasis>。 请注意，该技术更多的属于市场特性。在实际应用"
-"中，优化行读取比优化列读取更重要。但是，仅载入类的部分属性在某些特定情况下会"
-"有用，例如在原有表中拥有几百列数据、数据模型无法改动的情况下。 "
+msgid "Hibernate3 supports the lazy fetching of individual properties. This optimization technique is also known as <emphasis>fetch groups</emphasis>. Please note that this is mostly a marketing feature; optimizing row reads is much more important than optimization of column reads. However, only loading some properties of a class could be useful in extreme cases. For example, when legacy tables have hundreds of columns and the data model cannot be improved."
+msgstr "Hibernate3 对单独的属性支持延迟抓取，这项优化技术也被称为<emphasis>组抓取（fetch groups）</emphasis>。 请注意，该技术更多的属于市场特性。在实际应用中，优化行读取比优化列读取更重要。但是，仅载入类的部分属性在某些特定情况下会有用，例如在原有表中拥有几百列数据、数据模型无法改动的情况下。 "
#. Tag: para
#, no-c-format
-msgid ""
-"To enable lazy property loading, set the <literal>lazy</literal> attribute "
-"on your particular property mappings:"
-msgstr ""
-"可以在映射文件中对特定的属性设置 <literal>lazy</literal>，定义该属性为延迟载"
-"入。"
+msgid "To enable lazy property loading, set the <literal>lazy</literal> attribute on your particular property mappings:"
+msgstr "可以在映射文件中对特定的属性设置 <literal>lazy</literal>，定义该属性为延迟载入。"
#. Tag: para
#, no-c-format
-msgid ""
-"Lazy property loading requires buildtime bytecode instrumentation. If your "
-"persistent classes are not enhanced, Hibernate will ignore lazy property "
-"settings and return to immediate fetching."
-msgstr ""
-"属性的延迟载入要求在其代码构建时加入二进制指示指令（bytecode "
-"instrumentation），如果你的持久类代码中未含有这些指令， Hibernate 将会忽略这"
-"些属性的延迟设置，仍然将其直接载入。 "
+msgid "Lazy property loading requires buildtime bytecode instrumentation. If your persistent classes are not enhanced, Hibernate will ignore lazy property settings and return to immediate fetching."
+msgstr "属性的延迟载入要求在其代码构建时加入二进制指示指令（bytecode instrumentation），如果你的持久类代码中未含有这些指令， Hibernate 将会忽略这些属性的延迟设置，仍然将其直接载入。 "
#. Tag: para
#, no-c-format
@@ -856,23 +422,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A different way of avoiding unnecessary column reads, at least for read-only "
-"transactions, is to use the projection features of HQL or Criteria queries. "
-"This avoids the need for buildtime bytecode processing and is certainly a "
-"preferred solution."
-msgstr ""
-"还有一种可以优化的方法，它使用 HQL 或条件查询的投影（projection）特性，可以避"
-"免读取非必要的列， 这一点至少对只读事务是非常有用的。它无需在代码构建时“二进"
-"制指令”处理，因此是一个更加值得选择的解决方法。 "
+msgid "A different way of avoiding unnecessary column reads, at least for read-only transactions, is to use the projection features of HQL or Criteria queries. This avoids the need for buildtime bytecode processing and is certainly a preferred solution."
+msgstr "还有一种可以优化的方法，它使用 HQL 或条件查询的投影（projection）特性，可以避免读取非必要的列， 这一点至少对只读事务是非常有用的。它无需在代码构建时“二进制指令”处理，因此是一个更加值得选择的解决方法。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You can force the usual eager fetching of properties using <literal>fetch "
-"all properties</literal> in HQL."
-msgstr ""
-"有时你需要在 HQL 中通过<literal>抓取所有属性</literal>，强行抓取所有内容。 "
+msgid "You can force the usual eager fetching of properties using <literal>fetch all properties</literal> in HQL."
+msgstr "有时你需要在 HQL 中通过<literal>抓取所有属性</literal>，强行抓取所有内容。 "
#. Tag: title
#, no-c-format
@@ -881,38 +437,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A Hibernate <literal>Session</literal> is a transaction-level cache of "
-"persistent data. It is possible to configure a cluster or JVM-level "
-"(<literal>SessionFactory</literal>-level) cache on a class-by-class and "
-"collection-by-collection basis. You can even plug in a clustered cache. Be "
-"aware that caches are not aware of changes made to the persistent store by "
-"another application. They can, however, be configured to regularly expire "
-"cached data."
-msgstr ""
-"Hibernate 的 <literal>Session</literal> 在事务级别进行持久化数据的缓存操作。 "
-"当然，也有可能分别为每个类（或集合），配置集群、或 JVM 级别"
-"（<literal>SessionFactory 级别</literal>）的缓存。你甚至可以为之插入一个集群"
-"的缓存。注意，缓存永远不知道其他应用程序对持久化仓库（数据库）可能进行的修改 "
-"（即使可以将缓存数据设定为定期失效）。 "
+msgid "A Hibernate <literal>Session</literal> is a transaction-level cache of persistent data. It is possible to configure a cluster or JVM-level (<literal>SessionFactory</literal>-level) cache on a class-by-class and collection-by-collection basis. You can even plug in a clustered cache. Be aware that caches are not aware of changes made to the persistent store by another application. They can, however, be configured to regularly expire cached data."
+msgstr "Hibernate 的 <literal>Session</literal> 在事务级别进行持久化数据的缓存操作。 当然，也有可能分别为每个类（或集合），配置集群、或 JVM 级别（<literal>SessionFactory 级别</literal>）的缓存。你甚至可以为之插入一个集群的缓存。注意，缓存永远不知道其他应用程序对持久化仓库（数据库）可能进行的修改 （即使可以将缓存数据设定为定期失效）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You have the option to tell Hibernate which caching implementation to use by "
-"specifying the name of a class that implements <literal>org.hibernate.cache."
-"CacheProvider</literal> using the property <literal>hibernate.cache."
-"provider_class</literal>. Hibernate is bundled with a number of built-in "
-"integrations with the open-source cache providers that are listed below. You "
-"can also implement your own and plug it in as outlined above. Note that "
-"versions prior to 3.2 use EhCache as the default cache provider."
-msgstr ""
-"通过在 <literal>hibernate.cache.provider_class</literal> 属性中指定 "
-"<literal>org.hibernate.cache.CacheProvider</literal> 的某个实现的类名,你可以"
-"选择让 Hibernate 使用哪个缓存实现。Hibernate 打包一些开源缓存实现，提供对它们"
-"的内置支持（见下表）。除此之外，你也可以实现你自己的实现，将它们插入到系统"
-"中。注意，在 3.2 版本之前，默认使用 EhCache 作为缓存实现，但从 3.2 起就不再这"
-"样了。 "
+msgid "You have the option to tell Hibernate which caching implementation to use by specifying the name of a class that implements <literal>org.hibernate.cache.CacheProvider</literal> using the property <literal>hibernate.cache.provider_class</literal>. Hibernate is bundled with a number of built-in integrations with the open-source cache providers that are listed below. You can also implement your own and plug it in as outlined above. Note that versions prior to 3.2 use EhCache as the default cache provider."
+msgstr "通过在 <literal>hibernate.cache.provider_class</literal> 属性中指定 <literal>org.hibernate.cache.CacheProvider</literal> 的某个实现的类名,你可以选择让 Hibernate 使用哪个缓存实现。Hibernate 打包一些开源缓存实现，提供对它们的内置支持（见下表）。除此之外，你也可以实现你自己的实现，将它们插入到系统中。注意，在 3.2 版本之前，默认使用 EhCache 作为缓存实现，但从 3.2 起就不再这样了。 "
#. Tag: title
#, no-c-format
@@ -950,9 +481,9 @@
msgstr "Hashtable （not intended for production use）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>org.hibernate.cache.HashtableCacheProvider</literal>"
-msgstr "org.hibernate.cache.HashtableCacheProvider"
+msgstr "<literal>org.hibernate.cache.HashtableCacheProvider</literal>"
#. Tag: entry
#, no-c-format
@@ -962,7 +493,7 @@
#. Tag: entry
#, no-c-format
msgid "yes"
-msgstr ""
+msgstr "yes"
#. Tag: entry
#, no-c-format
@@ -970,9 +501,9 @@
msgstr "EHCache"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>org.hibernate.cache.EhCacheProvider</literal>"
-msgstr "org.hibernate.cache.EhCacheProvider"
+msgstr "<literal>org.hibernate.cache.EhCacheProvider</literal>"
#. Tag: entry
#, no-c-format
@@ -985,9 +516,9 @@
msgstr "OSCache"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>org.hibernate.cache.OSCacheProvider</literal>"
-msgstr "org.hibernate.cache.OSCacheProvider"
+msgstr "<literal>org.hibernate.cache.OSCacheProvider</literal>"
#. Tag: entry
#, no-c-format
@@ -995,9 +526,9 @@
msgstr "SwarmCache"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>org.hibernate.cache.SwarmCacheProvider</literal>"
-msgstr "org.hibernate.cache.SwarmCacheProvider"
+msgstr "<literal>org.hibernate.cache.SwarmCacheProvider</literal>"
#. Tag: entry
#, no-c-format
@@ -1015,9 +546,9 @@
msgstr "JBoss Cache 1.x"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>org.hibernate.cache.TreeCacheProvider</literal>"
-msgstr "org.hibernate.cache.TreeCacheProvider"
+msgstr "<literal>org.hibernate.cache.TreeCacheProvider</literal>"
#. Tag: entry
#, no-c-format
@@ -1040,9 +571,9 @@
msgstr "JBoss Cache 2"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>org.hibernate.cache.jbc2.JBossCacheRegionFactory</literal>"
-msgstr "org.hibernate.cache.jbc2.JBossCacheRegionFactory"
+msgstr "<literal>org.hibernate.cache.jbc2.JBossCacheRegionFactory</literal>"
#. Tag: entry
#, no-c-format
@@ -1056,64 +587,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal><cache></literal> element of a class or collection "
-"mapping has the following form:"
-msgstr ""
-"类或者集合映射的“<literal><cache></literal> 元素”可以有下列形式："
+msgid "The <literal><cache></literal> element of a class or collection mapping has the following form:"
+msgstr "类或者集合映射的“<literal><cache></literal> 元素”可以有下列形式："
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>usage</literal> (required) specifies the caching strategy: "
-"<literal>transactional</literal>, <literal>read-write</literal>, "
-"<literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
-msgstr ""
-"<literal>usage</literal>（必须）说明了缓存的策略：<literal>transactional</"
-"literal>、 <literal>read-write</literal>、<literal>nonstrict-read-write</"
-"literal> 或 <literal>read-only</literal>。"
+msgid "<literal>usage</literal> (required) specifies the caching strategy: <literal>transactional</literal>, <literal>read-write</literal>, <literal>nonstrict-read-write</literal> or <literal>read-only</literal>"
+msgstr "<literal>usage</literal>（必须）说明了缓存的策略：<literal>transactional</literal>、 <literal>read-write</literal>、<literal>nonstrict-read-write</literal> 或 <literal>read-only</literal>。"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>region</literal> (optional: defaults to the class or collection "
-"role name): specifies the name of the second level cache region"
-msgstr ""
-"<literal>region</literal> （可选，默认为类或者集合的名字（class or "
-"collection role name）） 指定第二级缓存的区域名（name of the second level "
-"cache region） "
+msgid "<literal>region</literal> (optional: defaults to the class or collection role name): specifies the name of the second level cache region"
+msgstr "<literal>region</literal> （可选，默认为类或者集合的名字（class or collection role name）） 指定第二级缓存的区域名（name of the second level cache region） "
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>include</literal> (optional: defaults to <literal>all</literal>) "
-"<literal>non-lazy</literal>: specifies that properties of the entity mapped "
-"with <literal>lazy=\"true\"</literal> cannot be cached when attribute-level "
-"lazy fetching is enabled"
-msgstr ""
-"<literal>include</literal>（可选,默认为 <literal>all</literal>） "
-"<literal>non-lazy</literal> 当属性级延迟抓取打开时，标记为 <literal>lazy="
-"\"true\"</literal> 的实体的属性可能无法被缓存 "
+msgid "<literal>include</literal> (optional: defaults to <literal>all</literal>) <literal>non-lazy</literal>: specifies that properties of the entity mapped with <literal>lazy=\"true\"</literal> cannot be cached when attribute-level lazy fetching is enabled"
+msgstr "<literal>include</literal>（可选,默认为 <literal>all</literal>） <literal>non-lazy</literal> 当属性级延迟抓取打开时，标记为 <literal>lazy=\"true\"</literal> 的实体的属性可能无法被缓存 "
#. Tag: para
#, no-c-format
-msgid ""
-"Alternatively, you can specify <literal><class-cache></literal> and "
-"<literal><collection-cache></literal> elements in <literal>hibernate."
-"cfg.xml</literal>."
-msgstr ""
-"另外（首选?），你可以在<literal>hibernate.cfg.xml</literal> 中指定 "
-"<literal><class-cache></literal> 和 <literal><collection-cache></"
-"literal> 元素。"
+msgid "Alternatively, you can specify <literal><class-cache></literal> and <literal><collection-cache></literal> elements in <literal>hibernate.cfg.xml</literal>."
+msgstr "另外（首选?），你可以在<literal>hibernate.cfg.xml</literal> 中指定 <literal><class-cache></literal> 和 <literal><collection-cache></literal> 元素。"
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>usage</literal> attribute specifies a <emphasis>cache "
-"concurrency strategy</emphasis>."
-msgstr ""
-"这里的 <literal>usage</literal> 属性指明了<emphasis>缓存并发策略（cache "
-"concurrency strategy）</emphasis>。"
+msgid "The <literal>usage</literal> attribute specifies a <emphasis>cache concurrency strategy</emphasis>."
+msgstr "这里的 <literal>usage</literal> 属性指明了<emphasis>缓存并发策略（cache concurrency strategy）</emphasis>。"
#. Tag: title
#, no-c-format
@@ -1122,15 +622,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If your application needs to read, but not modify, instances of a persistent "
-"class, a <literal>read-only</literal> cache can be used. This is the "
-"simplest and optimal performing strategy. It is even safe for use in a "
-"cluster."
-msgstr ""
-"如果你的应用程序只需读取一个持久化类的实例，而无需对其修改， 那么就可以对其进"
-"行<literal>只读</literal> 缓存。这是最简单，也是实用性最好的方法。甚至在集群"
-"中，它也能完美地运作。 "
+msgid "If your application needs to read, but not modify, instances of a persistent class, a <literal>read-only</literal> cache can be used. This is the simplest and optimal performing strategy. It is even safe for use in a cluster."
+msgstr "如果你的应用程序只需读取一个持久化类的实例，而无需对其修改， 那么就可以对其进行<literal>只读</literal> 缓存。这是最简单，也是实用性最好的方法。甚至在集群中，它也能完美地运作。 "
#. Tag: title
#, no-c-format
@@ -1139,28 +632,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If the application needs to update data, a <literal>read-write</literal> "
-"cache might be appropriate. This cache strategy should never be used if "
-"serializable transaction isolation level is required. If the cache is used "
-"in a JTA environment, you must specify the property <literal>hibernate."
-"transaction.manager_lookup_class</literal> and naming a strategy for "
-"obtaining the JTA <literal>TransactionManager</literal>. In other "
-"environments, you should ensure that the transaction is completed when "
-"<literal>Session.close()</literal> or <literal>Session.disconnect()</"
-"literal> is called. If you want to use this strategy in a cluster, you "
-"should ensure that the underlying cache implementation supports locking. The "
-"built-in cache providers <emphasis>do not</emphasis> support locking."
-msgstr ""
-"如果应用程序需要更新数据，那么使用<literal>读/写缓存</literal> 比较合适。 如"
-"果应用程序要求“序列化事务”的隔离级别（serializable transaction isolation "
-"level），那么就决不能使用这种缓存策略。 如果在 JTA 环境中使用缓存，你必须指"
-"定 <literal>hibernate.transaction.manager_lookup_class</literal> 属性的值， "
-"通过它，Hibernate 才能知道该应用程序中 JTA 的<literal>TransactionManager</"
-"literal>的具体策略。 在其它环境中，你必须保证在 <literal>Session.close()</"
-"literal>、或 <literal>Session.disconnect()</literal> 调用前， 整个事务已经结"
-"束。 如果你想在集群环境中使用此策略，你必须保证底层的缓存实现支持锁定"
-"（locking）。Hibernate 内置的缓存策略并不支持锁定功能。 "
+msgid "If the application needs to update data, a <literal>read-write</literal> cache might be appropriate. This cache strategy should never be used if serializable transaction isolation level is required. If the cache is used in a JTA environment, you must specify the property <literal>hibernate.transaction.manager_lookup_class</literal> and naming a strategy for obtaining the JTA <literal>TransactionManager</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called. If you want to use this strategy in a cluster, you should ensure that the underlying cache implementation supports locking. The built-in cache providers <emphasis>do not</emphasis> support locking."
+msgstr "如果应用程序需要更新数据，那么使用<literal>读/写缓存</literal> 比较合适。 如果应用程序要求“序列化事务”的隔离级别（serializable transaction isolation level），那么就决不能使用这种缓存策略。 如果在 JTA 环境中使用缓存，你必须指定 <literal>hibernate.transaction.manager_lookup_class</literal> 属性的值， 通过它，Hibernate 才能知道该应用程序中 JTA 的<literal>TransactionManager</literal>的具体策略。 在其它环境中，你必须保证在 <literal>Session.close()</literal>、或 <literal>Session.disconnect()</literal> 调用前， 整个事务已经结束。 如果你想在集群环境中使用此策略，你必须保证底层的缓存实现支持锁定（locking）。Hibernate 内置的缓存策略并不支持锁定功能。 "
#. Tag: title
#, no-c-format
@@ -1169,22 +642,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If the application only occasionally needs to update data (i.e. if it is "
-"extremely unlikely that two transactions would try to update the same item "
-"simultaneously), and strict transaction isolation is not required, a "
-"<literal>nonstrict-read-write</literal> cache might be appropriate. If the "
-"cache is used in a JTA environment, you must specify <literal>hibernate."
-"transaction.manager_lookup_class</literal>. In other environments, you "
-"should ensure that the transaction is completed when <literal>Session.close()"
-"</literal> or <literal>Session.disconnect()</literal> is called."
-msgstr ""
-"如果应用程序只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不"
-"常见），也不需要十分严格的事务隔离，那么比较适合使用<literal>非严格读/写缓存"
-"</literal>策略。如果在 JTA 环境中使用该策略，你必须为其指定 "
-"<literal>hibernate.transaction.manager_lookup_class</literal> 属性的值，在其"
-"它环境中，你必须保证在<literal>Session.close()</literal>、或 "
-"<literal>Session.disconnect()</literal> 调用前，整个事务已经结束。 "
+msgid "If the application only occasionally needs to update data (i.e. if it is extremely unlikely that two transactions would try to update the same item simultaneously), and strict transaction isolation is not required, a <literal>nonstrict-read-write</literal> cache might be appropriate. If the cache is used in a JTA environment, you must specify <literal>hibernate.transaction.manager_lookup_class</literal>. In other environments, you should ensure that the transaction is completed when <literal>Session.close()</literal> or <literal>Session.disconnect()</literal> is called."
+msgstr "如果应用程序只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离，那么比较适合使用<literal>非严格读/写缓存</literal>策略。如果在 JTA 环境中使用该策略，你必须为其指定 <literal>hibernate.transaction.manager_lookup_class</literal> 属性的值，在其它环境中，你必须保证在<literal>Session.close()</literal>、或 <literal>Session.disconnect()</literal> 调用前，整个事务已经结束。 "
#. Tag: title
#, no-c-format
@@ -1193,15 +652,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>transactional</literal> cache strategy provides support for "
-"fully transactional cache providers such as JBoss TreeCache. Such a cache "
-"can only be used in a JTA environment and you must specify "
-"<literal>hibernate.transaction.manager_lookup_class</literal>."
-msgstr ""
-"Hibernate 的<literal>事务缓存</literal>策略提供了全事务的缓存支持，例如对 "
-"JBoss TreeCache 的支持。这样的缓存只能用于 JTA 环境中，你必须指定为其 "
-"<literal>hibernate.transaction.manager_lookup_class</literal> 属性。 "
+msgid "The <literal>transactional</literal> cache strategy provides support for fully transactional cache providers such as JBoss TreeCache. Such a cache can only be used in a JTA environment and you must specify <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "Hibernate 的<literal>事务缓存</literal>策略提供了全事务的缓存支持，例如对 JBoss TreeCache 的支持。这样的缓存只能用于 JTA 环境中，你必须指定为其 <literal>hibernate.transaction.manager_lookup_class</literal> 属性。 "
#. Tag: title
#, no-c-format
@@ -1210,26 +662,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"None of the cache providers support all of the cache concurrency strategies."
-msgstr ""
-"没有一种缓存提供商能够支持上列的所有缓存并发策略。下表中列出了各种提供器、及"
-"其各自适用的并发策略。 "
+msgid "None of the cache providers support all of the cache concurrency strategies."
+msgstr "没有一种缓存提供商能够支持上列的所有缓存并发策略。下表中列出了各种提供器、及其各自适用的并发策略。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The following table shows which providers are compatible with which "
-"concurrency strategies."
-msgstr ""
-"没有一种缓存提供商能够支持上列的所有缓存并发策略。下表中列出了各种提供器、及"
-"其各自适用的并发策略。 "
+msgid "The following table shows which providers are compatible with which concurrency strategies."
+msgstr "没有一种缓存提供商能够支持上列的所有缓存并发策略。下表中列出了各种提供器、及其各自适用的并发策略。 "
#. Tag: title
#, no-c-format
msgid "Cache Concurrency Strategy Support"
-msgstr ""
-"各种缓存提供商对缓存并发策略的支持情况（Cache Concurrency Strategy Support）"
+msgstr "各种缓存提供商对缓存并发策略的支持情况（Cache Concurrency Strategy Support）"
#. Tag: entry
#, no-c-format
@@ -1258,125 +702,63 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Whenever you pass an object to <literal>save()</literal>, <literal>update()</"
-"literal> or <literal>saveOrUpdate()</literal>, and whenever you retrieve an "
-"object using <literal>load()</literal>, <literal>get()</literal>, "
-"<literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()"
-"</literal>, that object is added to the internal cache of the "
-"<literal>Session</literal>."
-msgstr ""
-"无论何时，当你给 <literal>save()</literal>、<literal>update()</literal> 或 "
-"<literal>saveOrUpdate()</literal> 方法传递一个对象时，或使用 <literal>load()"
-"</literal>、<literal>get()</literal>、<literal>list()</literal>、"
-"<literal>iterate()</literal> 或 <literal>scroll()</literal> 方法获得一个对象"
-"时，该对象都将被加入到 <literal>Session</literal> 的内部缓存中。 "
+msgid "Whenever you pass an object to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, and whenever you retrieve an object using <literal>load()</literal>, <literal>get()</literal>, <literal>list()</literal>, <literal>iterate()</literal> or <literal>scroll()</literal>, that object is added to the internal cache of the <literal>Session</literal>."
+msgstr "无论何时，当你给 <literal>save()</literal>、<literal>update()</literal> 或 <literal>saveOrUpdate()</literal> 方法传递一个对象时，或使用 <literal>load()</literal>、<literal>get()</literal>、<literal>list()</literal>、<literal>iterate()</literal> 或 <literal>scroll()</literal> 方法获得一个对象时，该对象都将被加入到 <literal>Session</literal> 的内部缓存中。 "
#. Tag: para
#, no-c-format
-msgid ""
-"When <literal>flush()</literal> is subsequently called, the state of that "
-"object will be synchronized with the database. If you do not want this "
-"synchronization to occur, or if you are processing a huge number of objects "
-"and need to manage memory efficiently, the <literal>evict()</literal> method "
-"can be used to remove the object and its collections from the first-level "
-"cache."
-msgstr ""
-"当随后 flush() 方法被调用时，对象的状态会和数据库取得同步。如果你不希望此同步"
-"操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用 "
-"<literal>evict()</literal> 方法，从一级缓存中去掉这些对象及其集合。 "
+msgid "When <literal>flush()</literal> is subsequently called, the state of that object will be synchronized with the database. If you do not want this synchronization to occur, or if you are processing a huge number of objects and need to manage memory efficiently, the <literal>evict()</literal> method can be used to remove the object and its collections from the first-level cache."
+msgstr "当随后 flush() 方法被调用时，对象的状态会和数据库取得同步。如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用 <literal>evict()</literal> 方法，从一级缓存中去掉这些对象及其集合。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>Session</literal> also provides a <literal>contains()</literal> "
-"method to determine if an instance belongs to the session cache."
-msgstr ""
-"Session 还提供了一个 <literal>contains()</literal> 方法，用来判断某个实例是否"
-"处于当前 session 的缓存中。"
+msgid "The <literal>Session</literal> also provides a <literal>contains()</literal> method to determine if an instance belongs to the session cache."
+msgstr "Session 还提供了一个 <literal>contains()</literal> 方法，用来判断某个实例是否处于当前 session 的缓存中。"
#. Tag: para
#, no-c-format
-msgid ""
-"To evict all objects from the session cache, call <literal>Session.clear()</"
-"literal>"
-msgstr ""
-"如若要把所有的对象从 session 缓存中彻底清除，则需要调用 <literal>Session."
-"clear()</literal>。 "
+msgid "To evict all objects from the session cache, call <literal>Session.clear()</literal>"
+msgstr "如若要把所有的对象从 session 缓存中彻底清除，则需要调用 <literal>Session.clear()</literal>。 "
#. Tag: para
#, no-c-format
-msgid ""
-"For the second-level cache, there are methods defined on "
-"<literal>SessionFactory</literal> for evicting the cached state of an "
-"instance, entire class, collection instance or entire collection role."
-msgstr ""
-"对于二级缓存来说，在 <literal>SessionFactory</literal> 中定义了许多方法，清除"
-"缓存中实例、整个类、集合实例或者整个集合。"
+msgid "For the second-level cache, there are methods defined on <literal>SessionFactory</literal> for evicting the cached state of an instance, entire class, collection instance or entire collection role."
+msgstr "对于二级缓存来说，在 <literal>SessionFactory</literal> 中定义了许多方法，清除缓存中实例、整个类、集合实例或者整个集合。"
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>CacheMode</literal> controls how a particular session interacts "
-"with the second-level cache:"
-msgstr ""
-"<literal>CacheMode</literal> 参数用于控制具体的 Session 如何与二级缓存进行交"
-"互。 "
+msgid "The <literal>CacheMode</literal> controls how a particular session interacts with the second-level cache:"
+msgstr "<literal>CacheMode</literal> 参数用于控制具体的 Session 如何与二级缓存进行交互。 "
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>CacheMode.NORMAL</literal>: will read items from and write items to "
-"the second-level cache"
+msgid "<literal>CacheMode.NORMAL</literal>: will read items from and write items to the second-level cache"
msgstr "<literal>CacheMode.NORMAL</literal>：从二级缓存中读、写数据。"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>CacheMode.GET</literal>: will read items from the second-level "
-"cache. Do not write to the second-level cache except when updating data"
-msgstr ""
-"<literal>CacheMode.GET</literal>：从二级缓存中读取数据，仅在数据更新时对二级"
-"缓存写数据。"
+msgid "<literal>CacheMode.GET</literal>: will read items from the second-level cache. Do not write to the second-level cache except when updating data"
+msgstr "<literal>CacheMode.GET</literal>：从二级缓存中读取数据，仅在数据更新时对二级缓存写数据。"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>CacheMode.PUT</literal>: will write items to the second-level "
-"cache. Do not read from the second-level cache"
-msgstr ""
-"<literal>CacheMode.PUT</literal>：仅向二级缓存写数据，但不从二级缓存中读数"
-"据。"
+msgid "<literal>CacheMode.PUT</literal>: will write items to the second-level cache. Do not read from the second-level cache"
+msgstr "<literal>CacheMode.PUT</literal>：仅向二级缓存写数据，但不从二级缓存中读数据。"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>CacheMode.REFRESH</literal>: will write items to the second-level "
-"cache. Do not read from the second-level cache. Bypass the effect of "
-"<literal>hibernate.cache.use_minimal_puts</literal> forcing a refresh of the "
-"second-level cache for all items read from the database"
-msgstr ""
-"<literal>CacheMode.REFRESH</literal>：仅向二级缓存写数据，但不从二级缓存中读"
-"数据。通过 <literal>hibernate.cache.use_minimal_puts</literal> 的设置，强制二"
-"级缓存从数据库中读取数据，刷新缓存内容。"
+msgid "<literal>CacheMode.REFRESH</literal>: will write items to the second-level cache. Do not read from the second-level cache. Bypass the effect of <literal>hibernate.cache.use_minimal_puts</literal> forcing a refresh of the second-level cache for all items read from the database"
+msgstr "<literal>CacheMode.REFRESH</literal>：仅向二级缓存写数据，但不从二级缓存中读数据。通过 <literal>hibernate.cache.use_minimal_puts</literal> 的设置，强制二级缓存从数据库中读取数据，刷新缓存内容。"
#. Tag: para
#, no-c-format
-msgid ""
-"To browse the contents of a second-level or query cache region, use the "
-"<literal>Statistics</literal> API:"
-msgstr ""
-"如若需要查看二级缓存或查询缓存区域的内容，你可以使用<literal>统计"
-"（Statistics）</literal> API。"
+msgid "To browse the contents of a second-level or query cache region, use the <literal>Statistics</literal> API:"
+msgstr "如若需要查看二级缓存或查询缓存区域的内容，你可以使用<literal>统计（Statistics）</literal> API。"
#. Tag: para
#, no-c-format
-msgid ""
-"You will need to enable statistics and, optionally, force Hibernate to keep "
-"the cache entries in a more readable format:"
-msgstr ""
-"此时，你必须手工打开统计选项。可选的，你可以让 Hibernate 更人工可读的方式维护"
-"缓存内容。 "
+msgid "You will need to enable statistics and, optionally, force Hibernate to keep the cache entries in a more readable format:"
+msgstr "此时，你必须手工打开统计选项。可选的，你可以让 Hibernate 更人工可读的方式维护缓存内容。 "
#. Tag: title
#, no-c-format
@@ -1385,70 +767,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Query result sets can also be cached. This is only useful for queries that "
-"are run frequently with the same parameters. You will first need to enable "
-"the query cache:"
-msgstr ""
-"查询的结果集也可以被缓存。只有当经常使用同样的参数进行查询时，这才会有些用"
-"处。要使用查询缓存，首先你必须打开它： "
+msgid "Query result sets can also be cached. This is only useful for queries that are run frequently with the same parameters. You will first need to enable the query cache:"
+msgstr "查询的结果集也可以被缓存。只有当经常使用同样的参数进行查询时，这才会有些用处。要使用查询缓存，首先你必须打开它： "
#. Tag: para
#, no-c-format
-msgid ""
-"This setting creates two new cache regions: one holding cached query result "
-"sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other "
-"holding timestamps of the most recent updates to queryable tables "
-"(<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that "
-"the query cache does not cache the state of the actual entities in the "
-"result set; it caches only identifier values and results of value type. The "
-"query cache should always be used in conjunction with the second-level cache."
-msgstr ""
-"该设置将会创建两个缓存区域 — 一个用于保存查询结果集（<literal>org.hibernate."
-"cache.StandardQueryCache</literal>）； 另一个则用于保存最近查询的一系列表的时"
-"间戳（<literal>org.hibernate.cache.UpdateTimestampsCache</literal>）。请注"
-"意：在查询缓存中，它并不缓存结果集中所包含的实体的确切状态；它只缓存这些实体"
-"的标识符属性的值、以及各值类型的结果。所以查询缓存通常会和二级缓存一起使用。 "
+msgid "This setting creates two new cache regions: one holding cached query result sets (<literal>org.hibernate.cache.StandardQueryCache</literal>), the other holding timestamps of the most recent updates to queryable tables (<literal>org.hibernate.cache.UpdateTimestampsCache</literal>). Note that the query cache does not cache the state of the actual entities in the result set; it caches only identifier values and results of value type. The query cache should always be used in conjunction with the second-level cache."
+msgstr "该设置将会创建两个缓存区域 — 一个用于保存查询结果集（<literal>org.hibernate.cache.StandardQueryCache</literal>）； 另一个则用于保存最近查询的一系列表的时间戳（<literal>org.hibernate.cache.UpdateTimestampsCache</literal>）。请注意：在查询缓存中，它并不缓存结果集中所包含的实体的确切状态；它只缓存这些实体的标识符属性的值、以及各值类型的结果。所以查询缓存通常会和二级缓存一起使用。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Most queries do not benefit from caching, so by default, queries are not "
-"cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. "
-"This call allows the query to look for existing cache results or add its "
-"results to the cache when it is executed."
-msgstr ""
-"绝大多数的查询并不能从查询缓存中受益，所以 Hibernate 默认是不进行查询缓存的。"
-"如若需要进行缓存，请调用 <literal>Query.setCacheable（true）</literal>方法。"
-"这个调用会让查询在执行过程中时先从缓存中查找结果，并将自己的结果集放到缓存中"
-"去。 "
+msgid "Most queries do not benefit from caching, so by default, queries are not cached. To enable caching, call <literal>Query.setCacheable(true)</literal>. This call allows the query to look for existing cache results or add its results to the cache when it is executed."
+msgstr "绝大多数的查询并不能从查询缓存中受益，所以 Hibernate 默认是不进行查询缓存的。如若需要进行缓存，请调用 <literal>Query.setCacheable（true）</literal>方法。这个调用会让查询在执行过程中时先从缓存中查找结果，并将自己的结果集放到缓存中去。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If you require fine-grained control over query cache expiration policies, "
-"you can specify a named cache region for a particular query by calling "
-"<literal>Query.setCacheRegion()</literal>."
-msgstr ""
-"如果你要对查询缓存的失效政策进行精确的控制，你必须调用 <literal>Query."
-"setCacheRegion()</literal> 方法，为每个查询指定其命名的缓存区域。 "
+msgid "If you require fine-grained control over query cache expiration policies, you can specify a named cache region for a particular query by calling <literal>Query.setCacheRegion()</literal>."
+msgstr "如果你要对查询缓存的失效政策进行精确的控制，你必须调用 <literal>Query.setCacheRegion()</literal> 方法，为每个查询指定其命名的缓存区域。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If the query should force a refresh of its query cache region, you should "
-"call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is "
-"particularly useful in cases where underlying data may have been updated via "
-"a separate process (i.e., not modified through Hibernate) and allows the "
-"application to selectively refresh particular query result sets. This is a "
-"more efficient alternative to eviction of a query cache region via "
-"<literal>SessionFactory.evictQueries()</literal>."
-msgstr ""
-"如果查询需要强行刷新其查询缓存区域，那么你应该调用 <literal>Query."
-"setCacheMode（CacheMode.REFRESH）</literal>方法。 这对在其他进程中修改底层数"
-"据（例如，不通过Hibernate修改数据），或对那些需要选择性更新特定查询结果集的情"
-"况特别有用。 这是对 <literal>SessionFactory.evictQueries()</literal> 的更为有"
-"效的替代方案，同样可以清除查询缓存区域。"
+msgid "If the query should force a refresh of its query cache region, you should call <literal>Query.setCacheMode(CacheMode.REFRESH)</literal>. This is particularly useful in cases where underlying data may have been updated via a separate process (i.e., not modified through Hibernate) and allows the application to selectively refresh particular query result sets. This is a more efficient alternative to eviction of a query cache region via <literal>SessionFactory.evictQueries()</literal>."
+msgstr "如果查询需要强行刷新其查询缓存区域，那么你应该调用 <literal>Query.setCacheMode（CacheMode.REFRESH）</literal>方法。 这对在其他进程中修改底层数据（例如，不通过Hibernate修改数据），或对那些需要选择性更新特定查询结果集的情况特别有用。 这是对 <literal>SessionFactory.evictQueries()</literal> 的更为有效的替代方案，同样可以清除查询缓存区域。"
#. Tag: title
#, no-c-format
@@ -1457,13 +797,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"In the previous sections we have covered collections and their applications. "
-"In this section we explore some more issues in relation to collections at "
-"runtime."
-msgstr ""
-"在前面的章节里我们已经讨论了集合和相关应用程序。在本节我么将探索运行时集合的"
-"更多问题。"
+msgid "In the previous sections we have covered collections and their applications. In this section we explore some more issues in relation to collections at runtime."
+msgstr "在前面的章节里我们已经讨论了集合和相关应用程序。在本节我么将探索运行时集合的更多问题。"
#. Tag: title
#, no-c-format
@@ -1492,17 +827,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"This classification distinguishes the various table and foreign key "
-"relationships but does not tell us quite everything we need to know about "
-"the relational model. To fully understand the relational structure and "
-"performance characteristics, we must also consider the structure of the "
-"primary key that is used by Hibernate to update or delete collection rows. "
-"This suggests the following classification:"
-msgstr ""
-"这个分类是区分了不同的表和外键关系类型，但是它没有告诉我们关系模型的所有内"
-"容。 要完全理解他们的关系结构和性能特点，我们必须同时考虑“用于 Hibernate 更新"
-"或删除集合行数据的主键的结构”。因此得到了如下的分类："
+msgid "This classification distinguishes the various table and foreign key relationships but does not tell us quite everything we need to know about the relational model. To fully understand the relational structure and performance characteristics, we must also consider the structure of the primary key that is used by Hibernate to update or delete collection rows. This suggests the following classification:"
+msgstr "这个分类是区分了不同的表和外键关系类型，但是它没有告诉我们关系模型的所有内容。 要完全理解他们的关系结构和性能特点，我们必须同时考虑“用于 Hibernate 更新或删除集合行数据的主键的结构”。因此得到了如下的分类："
#. Tag: para
#, no-c-format
@@ -1521,131 +847,53 @@
#. Tag: para
#, no-c-format
-msgid ""
-"All indexed collections (maps, lists, and arrays) have a primary key "
-"consisting of the <literal><key></literal> and <literal><index></"
-"literal> columns. In this case, collection updates are extremely efficient. "
-"The primary key can be efficiently indexed and a particular row can be "
-"efficiently located when Hibernate tries to update or delete it."
-msgstr ""
-"所有的有序集合类（maps，lists，arrays）都拥有一个由 <literal><key></"
-"literal> 和 <literal><index></literal> 组成的主键。这种情况下集合类的更"
-"新是非常高效的 — 主键已经被有效的索引，因此当 Hibernate 试图更新或删除一行"
-"时，可以迅速找到该行数据。 "
+msgid "All indexed collections (maps, lists, and arrays) have a primary key consisting of the <literal><key></literal> and <literal><index></literal> columns. In this case, collection updates are extremely efficient. The primary key can be efficiently indexed and a particular row can be efficiently located when Hibernate tries to update or delete it."
+msgstr "所有的有序集合类（maps，lists，arrays）都拥有一个由 <literal><key></literal> 和 <literal><index></literal> 组成的主键。这种情况下集合类的更新是非常高效的 — 主键已经被有效的索引，因此当 Hibernate 试图更新或删除一行时，可以迅速找到该行数据。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Sets have a primary key consisting of <literal><key></literal> and "
-"element columns. This can be less efficient for some types of collection "
-"element, particularly composite elements or large text or binary fields, as "
-"the database may not be able to index a complex primary key as efficiently. "
-"However, for one-to-many or many-to-many associations, particularly in the "
-"case of synthetic identifiers, it is likely to be just as efficient. If you "
-"want <literal>SchemaExport</literal> to actually create the primary key of a "
-"<literal><set></literal>, you must declare all columns as <literal>not-"
-"null=\"true\"</literal>."
-msgstr ""
-"集合（sets）的主键由 <literal><key></literal> 和其他元素字段构成。对于"
-"有些元素类型来说，这很低效，特别是组合元素或者大文本、大二进制字段；数据库可"
-"能无法有效的对复杂的主键进行索引。另一方面，对于一对多、多对多关联，特别是合"
-"成的标识符来说，集合也可以达到同样的高效性能。（ 附注：如果你希望 "
-"<literal>SchemaExport</literal> 为你的 <literal><set></literal> 创建主"
-"键，你必须把所有的字段都声明为 <literal>not-null=\"true\"</literal>。） "
+msgid "Sets have a primary key consisting of <literal><key></literal> and element columns. This can be less efficient for some types of collection element, particularly composite elements or large text or binary fields, as the database may not be able to index a complex primary key as efficiently. However, for one-to-many or many-to-many associations, particularly in the case of synthetic identifiers, it is likely to be just as efficient. If you want <literal>SchemaExport</literal> to actually create the primary key of a <literal><set></literal>, you must declare all columns as <literal>not-null=\"true\"</literal>."
+msgstr "集合（sets）的主键由 <literal><key></literal> 和其他元素字段构成。对于有些元素类型来说，这很低效，特别是组合元素或者大文本、大二进制字段；数据库可能无法有效的对复杂的主键进行索引。另一方面，对于一对多、多对多关联，特别是合成的标识符来说，集合也可以达到同样的高效性能。（ 附注：如果你希望 <literal>SchemaExport</literal> 为你的 <literal><set></literal> 创建主键，你必须把所有的字段都声明为 <literal>not-null=\"true\"</literal>。） "
#. Tag: para
#, no-c-format
-msgid ""
-"<literal><idbag></literal> mappings define a surrogate key, so they "
-"are efficient to update. In fact, they are the best case."
-msgstr ""
-"<literal><idbag></literal> 映射定义了代理键，因此它总是可以很高效的被更"
-"新。事实上，<literal><idbag></literal> 拥有着最好的性能表现。 "
+msgid "<literal><idbag></literal> mappings define a surrogate key, so they are efficient to update. In fact, they are the best case."
+msgstr "<literal><idbag></literal> 映射定义了代理键，因此它总是可以很高效的被更新。事实上，<literal><idbag></literal> 拥有着最好的性能表现。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Bags are the worst case since they permit duplicate element values and, as "
-"they have no index column, no primary key can be defined. Hibernate has no "
-"way of distinguishing between duplicate rows. Hibernate resolves this "
-"problem by completely removing in a single <literal>DELETE</literal> and "
-"recreating the collection whenever it changes. This can be inefficient."
-msgstr ""
-"Bag 是最差的。因为 bag 允许重复的元素值，也没有索引字段，因此不可能定义主"
-"键。 Hibernate 无法判断出重复的行。当这种集合被更改时，Hibernate 将会先完整地"
-"移除 （通过一个（in a single <literal>DELETE</literal>））整个集合，然后再重"
-"新创建整个集合。因此 Bag 是非常低效的。 "
+msgid "Bags are the worst case since they permit duplicate element values and, as they have no index column, no primary key can be defined. Hibernate has no way of distinguishing between duplicate rows. Hibernate resolves this problem by completely removing in a single <literal>DELETE</literal> and recreating the collection whenever it changes. This can be inefficient."
+msgstr "Bag 是最差的。因为 bag 允许重复的元素值，也没有索引字段，因此不可能定义主键。 Hibernate 无法判断出重复的行。当这种集合被更改时，Hibernate 将会先完整地移除 （通过一个（in a single <literal>DELETE</literal>））整个集合，然后再重新创建整个集合。因此 Bag 是非常低效的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"For a one-to-many association, the \"primary key\" may not be the physical "
-"primary key of the database table. Even in this case, the above "
-"classification is still useful. It reflects how Hibernate \"locates\" "
-"individual rows of the collection."
-msgstr ""
-"请注意：对于一对多关联来说，“主键”很可能并不是数据库表的物理主键。但就算在此"
-"情况下，上面的分类仍然是有用的。（它仍然反映了 Hibernate 在集合的各数据行中是"
-"如何进行“定位”的。） "
+msgid "For a one-to-many association, the \"primary key\" may not be the physical primary key of the database table. Even in this case, the above classification is still useful. It reflects how Hibernate \"locates\" individual rows of the collection."
+msgstr "请注意：对于一对多关联来说，“主键”很可能并不是数据库表的物理主键。但就算在此情况下，上面的分类仍然是有用的。（它仍然反映了 Hibernate 在集合的各数据行中是如何进行“定位”的。） "
#. Tag: title
#, no-c-format
-msgid ""
-"Lists, maps, idbags and sets are the most efficient collections to update"
+msgid "Lists, maps, idbags and sets are the most efficient collections to update"
msgstr "Lists，maps 和 sets 用于更新效率最高"
#. Tag: para
#, no-c-format
-msgid ""
-"From the discussion above, it should be clear that indexed collections and "
-"sets allow the most efficient operation in terms of adding, removing and "
-"updating elements."
-msgstr ""
-"根据我们上面的讨论，显然有序集合类型和大多数 set 都可以在增加、删除、修改元素"
-"中拥有最好的性能。 "
+msgid "From the discussion above, it should be clear that indexed collections and sets allow the most efficient operation in terms of adding, removing and updating elements."
+msgstr "根据我们上面的讨论，显然有序集合类型和大多数 set 都可以在增加、删除、修改元素中拥有最好的性能。 "
#. Tag: para
#, no-c-format
-msgid ""
-"There is, arguably, one more advantage that indexed collections have over "
-"sets for many-to-many associations or collections of values. Because of the "
-"structure of a <literal>Set</literal>, Hibernate does not <literal>UPDATE</"
-"literal> a row when an element is \"changed\". Changes to a <literal>Set</"
-"literal> always work via <literal>INSERT</literal> and <literal>DELETE</"
-"literal> of individual rows. Once again, this consideration does not apply "
-"to one-to-many associations."
-msgstr ""
-"可论证的是对于多对多关联、值数据集合而言，有序集合类比集合（set）有一个好处。"
-"因为 <literal>Set</literal> 的内在结构， 如果“改变”了一个元素，Hibernate 并不"
-"会<literal>更新（UPDATE）</literal>这一行。对于 <literal>Set</literal> 来说，"
-"只有在<literal>插入（INSERT）</literal>和<literal>删除（DELETE）</literal> 操"
-"作时“改变”才有效。再次强调：这段讨论对“一对多关联”并不适用。 "
+msgid "There is, arguably, one more advantage that indexed collections have over sets for many-to-many associations or collections of values. Because of the structure of a <literal>Set</literal>, Hibernate does not <literal>UPDATE</literal> a row when an element is \"changed\". Changes to a <literal>Set</literal> always work via <literal>INSERT</literal> and <literal>DELETE</literal> of individual rows. Once again, this consideration does not apply to one-to-many associations."
+msgstr "可论证的是对于多对多关联、值数据集合而言，有序集合类比集合（set）有一个好处。因为 <literal>Set</literal> 的内在结构， 如果“改变”了一个元素，Hibernate 并不会<literal>更新（UPDATE）</literal>这一行。对于 <literal>Set</literal> 来说，只有在<literal>插入（INSERT）</literal>和<literal>删除（DELETE）</literal> 操作时“改变”才有效。再次强调：这段讨论对“一对多关联”并不适用。 "
#. Tag: para
#, no-c-format
-msgid ""
-"After observing that arrays cannot be lazy, you can conclude that lists, "
-"maps and idbags are the most performant (non-inverse) collection types, with "
-"sets not far behind. You can expect sets to be the most common kind of "
-"collection in Hibernate applications. This is because the \"set\" semantics "
-"are most natural in the relational model."
-msgstr ""
-"注意到数组无法延迟载入，我们可以得出结论，list，map 和 idbags 是最高效的（非"
-"反向）集合类型，set 则紧随其后。 在 Hibernate 中，set 应该时最通用的集合类"
-"型，这时因为“set”的语义在关系模型中是最自然的。 "
+msgid "After observing that arrays cannot be lazy, you can conclude that lists, maps and idbags are the most performant (non-inverse) collection types, with sets not far behind. You can expect sets to be the most common kind of collection in Hibernate applications. This is because the \"set\" semantics are most natural in the relational model."
+msgstr "注意到数组无法延迟载入，我们可以得出结论，list，map 和 idbags 是最高效的（非反向）集合类型，set 则紧随其后。 在 Hibernate 中，set 应该时最通用的集合类型，这时因为“set”的语义在关系模型中是最自然的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"However, in well-designed Hibernate domain models, most collections are in "
-"fact one-to-many associations with <literal>inverse=\"true\"</literal>. For "
-"these associations, the update is handled by the many-to-one end of the "
-"association, and so considerations of collection update performance simply "
-"do not apply."
-msgstr ""
-"但是，在设计良好的 Hibernate 领域模型中，我们通常可以看到更多的集合事实上是带"
-"有 <literal>inverse=\"true\"</literal> 的一对多的关联。对于这些关联，更新操"
-"作将会在多对一的这一端进行处理。因此对于此类情况，无需考虑其集合的更新性能。 "
+msgid "However, in well-designed Hibernate domain models, most collections are in fact one-to-many associations with <literal>inverse=\"true\"</literal>. For these associations, the update is handled by the many-to-one end of the association, and so considerations of collection update performance simply do not apply."
+msgstr "但是，在设计良好的 Hibernate 领域模型中，我们通常可以看到更多的集合事实上是带有 <literal>inverse=\"true\"</literal> 的一对多的关联。对于这些关联，更新操作将会在多对一的这一端进行处理。因此对于此类情况，无需考虑其集合的更新性能。 "
#. Tag: title
#, no-c-format
@@ -1654,22 +902,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"There is a particular case, however, in which bags, and also lists, are much "
-"more performant than sets. For a collection with <literal>inverse=\"true\"</"
-"literal>, the standard bidirectional one-to-many relationship idiom, for "
-"example, we can add elements to a bag or list without needing to initialize "
-"(fetch) the bag elements. This is because, unlike a <literal>set</literal>, "
-"<literal>Collection.add()</literal> or <literal>Collection.addAll()</"
-"literal> must always return true for a bag or <literal>List</literal>. This "
-"can make the following common code much faster:"
-msgstr ""
-"在把 bag 扔进水沟之前，你必须了解，在一种情况下，bag 的性能（包括list）要比 "
-"set 高得多：对于指明了 <literal>inverse=\"true\"</literal> 的集合类（比如说，"
-"标准的双向的一对多关联），我们可以在未初始化（fetch）包元素的情况下直接向 "
-"bag 或 list 添加新元素！ 这是因为 <literal>Collection.add()</literal>）或者 "
-"<literal>Collection.addAll()</literal> 方法对 bag 或者 List 总是返回 true（这"
-"点与与 Set 不同）。因此对于下面的相同代码来说，速度会快得多。 "
+msgid "There is a particular case, however, in which bags, and also lists, are much more performant than sets. For a collection with <literal>inverse=\"true\"</literal>, the standard bidirectional one-to-many relationship idiom, for example, we can add elements to a bag or list without needing to initialize (fetch) the bag elements. This is because, unlike a <literal>set</literal>, <literal>Collection.add()</literal> or <literal>Collection.addAll()</literal> must always return true for a bag or <literal>List</literal>. This can make the following common code much faster:"
+msgstr "在把 bag 扔进水沟之前，你必须了解，在一种情况下，bag 的性能（包括list）要比 set 高得多：对于指明了 <literal>inverse=\"true\"</literal> 的集合类（比如说，标准的双向的一对多关联），我们可以在未初始化（fetch）包元素的情况下直接向 bag 或 list 添加新元素！ 这是因为 <literal>Collection.add()</literal>）或者 <literal>Collection.addAll()</literal> 方法对 bag 或者 List 总是返回 true（这点与与 Set 不同）。因此对于下面的相同代码来说，速度会快得多。 "
#. Tag: title
#, no-c-format
@@ -1678,36 +912,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Deleting collection elements one by one can sometimes be extremely "
-"inefficient. Hibernate knows not to do that in the case of an newly-empty "
-"collection (if you called <literal>list.clear()</literal>, for example). In "
-"this case, Hibernate will issue a single <literal>DELETE</literal>."
-msgstr ""
-"偶尔的，逐个删除集合类中的元素是相当低效的。Hibernate 并没那么笨，如果你想要"
-"把整个集合都删除（比如说调用 list.clear()），Hibernate 只需要一个 DELETE 就搞"
-"定了。 "
+msgid "Deleting collection elements one by one can sometimes be extremely inefficient. Hibernate knows not to do that in the case of an newly-empty collection (if you called <literal>list.clear()</literal>, for example). In this case, Hibernate will issue a single <literal>DELETE</literal>."
+msgstr "偶尔的，逐个删除集合类中的元素是相当低效的。Hibernate 并没那么笨，如果你想要把整个集合都删除（比如说调用 list.clear()），Hibernate 只需要一个 DELETE 就搞定了。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Suppose you added a single element to a collection of size twenty and then "
-"remove two elements. Hibernate will issue one <literal>INSERT</literal> "
-"statement and two <literal>DELETE</literal> statements, unless the "
-"collection is a bag. This is certainly desirable."
-msgstr ""
-"假设我们在一个长度为20的集合类中新增加了一个元素，然后再删除两个。Hibernate "
-"会安排一条 <literal>INSERT</literal> 语句和两条 <literal>DELETE</literal> 语"
-"句（除非集合类是一个 bag）。这当然是令人满意的。 "
+msgid "Suppose you added a single element to a collection of size twenty and then remove two elements. Hibernate will issue one <literal>INSERT</literal> statement and two <literal>DELETE</literal> statements, unless the collection is a bag. This is certainly desirable."
+msgstr "假设我们在一个长度为20的集合类中新增加了一个元素，然后再删除两个。Hibernate 会安排一条 <literal>INSERT</literal> 语句和两条 <literal>DELETE</literal> 语句（除非集合类是一个 bag）。这当然是令人满意的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"However, suppose that we remove eighteen elements, leaving two and then add "
-"thee new elements. There are two possible ways to proceed"
-msgstr ""
-"但是，假设我们删除了 18 个数据，只剩下 2 个，然后新增 3 个。则有两种处理方"
-"式："
+msgid "However, suppose that we remove eighteen elements, leaving two and then add thee new elements. There are two possible ways to proceed"
+msgstr "但是，假设我们删除了 18 个数据，只剩下 2 个，然后新增 3 个。则有两种处理方式："
#. Tag: para
#, no-c-format
@@ -1716,40 +932,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"remove the whole collection in one SQL <literal>DELETE</literal> and insert "
-"all five current elements one by one"
+msgid "remove the whole collection in one SQL <literal>DELETE</literal> and insert all five current elements one by one"
msgstr "删除整个集合类（只用一句 DELETE 语句），然后逐一添加 5 个数据。"
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate cannot know that the second option is probably quicker. It would "
-"probably be undesirable for Hibernate to be that intuitive as such behavior "
-"might confuse database triggers, etc."
-msgstr ""
-"Hibernate 还没那么聪明，知道第二种选择可能会比较快。（也许让 Hibernate 不这么"
-"聪明也是好事，否则可能会引发意外的“数据库触发器”之类的问题。）"
+msgid "Hibernate cannot know that the second option is probably quicker. It would probably be undesirable for Hibernate to be that intuitive as such behavior might confuse database triggers, etc."
+msgstr "Hibernate 还没那么聪明，知道第二种选择可能会比较快。（也许让 Hibernate 不这么聪明也是好事，否则可能会引发意外的“数据库触发器”之类的问题。）"
#. Tag: para
#, no-c-format
-msgid ""
-"Fortunately, you can force this behavior (i.e. the second strategy) at any "
-"time by discarding (i.e. dereferencing) the original collection and "
-"returning a newly instantiated collection with all the current elements."
-msgstr ""
-"幸运的是，你可以强制使用第二种策略。你需要取消原来的整个集合类（解除其引"
-"用），然后再返回一个新的实例化的集合类，只包含需要的元素。有些时候这是非常有"
-"用的。 "
+msgid "Fortunately, you can force this behavior (i.e. the second strategy) at any time by discarding (i.e. dereferencing) the original collection and returning a newly instantiated collection with all the current elements."
+msgstr "幸运的是，你可以强制使用第二种策略。你需要取消原来的整个集合类（解除其引用），然后再返回一个新的实例化的集合类，只包含需要的元素。有些时候这是非常有用的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"One-shot-delete does not apply to collections mapped <literal>inverse=\"true"
-"\"</literal>."
-msgstr ""
-"显然，一次性删除并不适用于被映射为 <literal>inverse=\"true\"</literal> 的集"
-"合。 "
+msgid "One-shot-delete does not apply to collections mapped <literal>inverse=\"true\"</literal>."
+msgstr "显然，一次性删除并不适用于被映射为 <literal>inverse=\"true\"</literal> 的集合。 "
#. Tag: title
#, no-c-format
@@ -1758,14 +957,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Optimization is not much use without monitoring and access to performance "
-"numbers. Hibernate provides a full range of figures about its internal "
-"operations. Statistics in Hibernate are available per "
-"<literal>SessionFactory</literal>."
-msgstr ""
-"没有监测和性能参数而进行优化是毫无意义的。Hibernate 为其内部操作提供了一系列"
-"的示意图，因此可以从 每个 <literal>SessionFactory</literal> 抓取其统计数据。"
+msgid "Optimization is not much use without monitoring and access to performance numbers. Hibernate provides a full range of figures about its internal operations. Statistics in Hibernate are available per <literal>SessionFactory</literal>."
+msgstr "没有监测和性能参数而进行优化是毫无意义的。Hibernate 为其内部操作提供了一系列的示意图，因此可以从 每个 <literal>SessionFactory</literal> 抓取其统计数据。"
#. Tag: title
#, no-c-format
@@ -1774,64 +967,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"You can access <literal>SessionFactory</literal> metrics in two ways. Your "
-"first option is to call <literal>sessionFactory.getStatistics()</literal> "
-"and read or display the <literal>Statistics</literal> yourself."
-msgstr ""
-"你可以有两种方式访问 <literal>SessionFactory</literal> 的数据记录，第一种就是"
-"自己直接调用 <literal>sessionFactory.getStatistics()</literal> 方法读取、显示"
-"<literal>统计</literal>数据。"
+msgid "You can access <literal>SessionFactory</literal> metrics in two ways. Your first option is to call <literal>sessionFactory.getStatistics()</literal> and read or display the <literal>Statistics</literal> yourself."
+msgstr "你可以有两种方式访问 <literal>SessionFactory</literal> 的数据记录，第一种就是自己直接调用 <literal>sessionFactory.getStatistics()</literal> 方法读取、显示<literal>统计</literal>数据。"
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate can also use JMX to publish metrics if you enable the "
-"<literal>StatisticsService</literal> MBean. You can enable a single MBean "
-"for all your <literal>SessionFactory</literal> or one per factory. See the "
-"following code for minimalistic configuration examples:"
-msgstr ""
-"此外，如果你打开 <literal>StatisticsService</literal> MBean 选项，那么 "
-"Hibernate 则可以使用 JMX 技术 发布其数据记录。你可以让应用中所有的 "
-"<literal>SessionFactory</literal> 同时共享一个 MBean，也可以每个 "
-"SessionFactory 分配一个 MBean。下面的代码即是其演示代码： "
+msgid "Hibernate can also use JMX to publish metrics if you enable the <literal>StatisticsService</literal> MBean. You can enable a single MBean for all your <literal>SessionFactory</literal> or one per factory. See the following code for minimalistic configuration examples:"
+msgstr "此外，如果你打开 <literal>StatisticsService</literal> MBean 选项，那么 Hibernate 则可以使用 JMX 技术 发布其数据记录。你可以让应用中所有的 <literal>SessionFactory</literal> 同时共享一个 MBean，也可以每个 SessionFactory 分配一个 MBean。下面的代码即是其演示代码： "
#. Tag: para
#, no-c-format
-msgid ""
-"You can activate and deactivate the monitoring for a "
-"<literal>SessionFactory</literal>:"
-msgstr ""
-"你可以通过以下方法打开或关闭 <literal>SessionFactory</literal> 的监测功能： "
+msgid "You can activate and deactivate the monitoring for a <literal>SessionFactory</literal>:"
+msgstr "你可以通过以下方法打开或关闭 <literal>SessionFactory</literal> 的监测功能： "
#. Tag: para
#, no-c-format
-msgid ""
-"at configuration time, set <literal>hibernate.generate_statistics</literal> "
-"to <literal>false</literal>"
-msgstr ""
-"在配置期间，将 <literal>hibernate.generate_statistics</literal> 设置为 "
-"<literal>true</literal> 或 <literal>false</literal>；"
+msgid "at configuration time, set <literal>hibernate.generate_statistics</literal> to <literal>false</literal>"
+msgstr "在配置期间，将 <literal>hibernate.generate_statistics</literal> 设置为 <literal>true</literal> 或 <literal>false</literal>；"
#. Tag: para
#, no-c-format
-msgid ""
-"at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> "
-"or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
-msgstr ""
-"在运行期间，则可以可以通过 <literal>sf.getStatistics().setStatisticsEnabled"
-"(true)</literal> 或 <literal>hibernateStatsBean.setStatisticsEnabled(true)</"
-"literal>"
+msgid "at runtime: <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> or <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
+msgstr "在运行期间，则可以可以通过 <literal>sf.getStatistics().setStatisticsEnabled(true)</literal> 或 <literal>hibernateStatsBean.setStatisticsEnabled(true)</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"Statistics can be reset programmatically using the <literal>clear()</"
-"literal> method. A summary can be sent to a logger (info level) using the "
-"<literal>logSummary()</literal> method."
-msgstr ""
-"你也可以在程序中调用 <literal>clear()</literal> 方法重置统计数据，调用 "
-"<literal>logSummary()</literal> 在日志中记录（info 级别）其总结。 "
+msgid "Statistics can be reset programmatically using the <literal>clear()</literal> method. A summary can be sent to a logger (info level) using the <literal>logSummary()</literal> method."
+msgstr "你也可以在程序中调用 <literal>clear()</literal> 方法重置统计数据，调用 <literal>logSummary()</literal> 在日志中记录（info 级别）其总结。 "
#. Tag: title
#, no-c-format
@@ -1840,85 +1002,38 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate provides a number of metrics, from basic information to more "
-"specialized information that is only relevant in certain scenarios. All "
-"available counters are described in the <literal>Statistics</literal> "
-"interface API, in three categories:"
-msgstr ""
-"Hibernate 提供了一系列数据记录，其记录的内容包括从最基本的信息到与具体场景的"
-"特殊信息。所有的测量值都可以由 <literal>Statistics</literal> 接口 API 进行访"
-"问，主要分为三类："
+msgid "Hibernate provides a number of metrics, from basic information to more specialized information that is only relevant in certain scenarios. All available counters are described in the <literal>Statistics</literal> interface API, in three categories:"
+msgstr "Hibernate 提供了一系列数据记录，其记录的内容包括从最基本的信息到与具体场景的特殊信息。所有的测量值都可以由 <literal>Statistics</literal> 接口 API 进行访问，主要分为三类："
#. Tag: para
#, no-c-format
-msgid ""
-"Metrics related to the general <literal>Session</literal> usage, such as "
-"number of open sessions, retrieved JDBC connections, etc."
-msgstr ""
-"使用 <literal>Session</literal> 的普通数据记录，例如打开的 Session 的个数、取"
-"得的 JDBC 的连接数等；"
+msgid "Metrics related to the general <literal>Session</literal> usage, such as number of open sessions, retrieved JDBC connections, etc."
+msgstr "使用 <literal>Session</literal> 的普通数据记录，例如打开的 Session 的个数、取得的 JDBC 的连接数等；"
#. Tag: para
#, no-c-format
-msgid ""
-"Metrics related to the entities, collections, queries, and caches as a whole "
-"(aka global metrics)."
+msgid "Metrics related to the entities, collections, queries, and caches as a whole (aka global metrics)."
msgstr "实体、集合、查询、缓存等内容的统一数据记录。"
#. Tag: para
#, no-c-format
-msgid ""
-"Detailed metrics related to a particular entity, collection, query or cache "
-"region."
+msgid "Detailed metrics related to a particular entity, collection, query or cache region."
msgstr "和具体实体、集合、查询、缓存相关的详细数据记录"
#. Tag: para
#, no-c-format
-msgid ""
-"For example, you can check the cache hit, miss, and put ratio of entities, "
-"collections and queries, and the average time a query needs. Be aware that "
-"the number of milliseconds is subject to approximation in Java. Hibernate is "
-"tied to the JVM precision and on some platforms this might only be accurate "
-"to 10 seconds."
-msgstr ""
-"例如：你可以检查缓存的命中成功次数，缓存的命中失败次数，实体、集合和查询的使"
-"用概率，查询的平均时间等。请注意 Java 中时间的近似精度是毫秒。Hibernate 的数"
-"据精度和具体的 JVM 有关，在有些平台上其精度甚至只能精确到 10 秒。 "
+msgid "For example, you can check the cache hit, miss, and put ratio of entities, collections and queries, and the average time a query needs. Be aware that the number of milliseconds is subject to approximation in Java. Hibernate is tied to the JVM precision and on some platforms this might only be accurate to 10 seconds."
+msgstr "例如：你可以检查缓存的命中成功次数，缓存的命中失败次数，实体、集合和查询的使用概率，查询的平均时间等。请注意 Java 中时间的近似精度是毫秒。Hibernate 的数据精度和具体的 JVM 有关，在有些平台上其精度甚至只能精确到 10 秒。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Simple getters are used to access the global metrics (i.e. not tied to a "
-"particular entity, collection, cache region, etc.). You can access the "
-"metrics of a particular entity, collection or cache region through its name, "
-"and through its HQL or SQL representation for queries. Please refer to the "
-"<literal>Statistics</literal>, <literal>EntityStatistics</literal>, "
-"<literal>CollectionStatistics</literal>, "
-"<literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</"
-"literal> API Javadoc for more information. The following code is a simple "
-"example:"
-msgstr ""
-"你可以直接使用 getter 方法得到全局数据记录（例如，和具体的实体、集合、缓存区"
-"无关的数据），你也可以在具体查询中通过标记实体名、 或 HQL、SQL 语句得到某实体"
-"的数据记录。请参考 <literal>Statistics</literal>、<literal>EntityStatistics</"
-"literal>、<literal>CollectionStatistics</literal>、"
-"<literal>SecondLevelCacheStatistics</literal> 和 <literal>QueryStatistics</"
-"literal> 的 API 文档以抓取更多信息。下面的代码则是个简单的例子： "
+msgid "Simple getters are used to access the global metrics (i.e. not tied to a particular entity, collection, cache region, etc.). You can access the metrics of a particular entity, collection or cache region through its name, and through its HQL or SQL representation for queries. Please refer to the <literal>Statistics</literal>, <literal>EntityStatistics</literal>, <literal>CollectionStatistics</literal>, <literal>SecondLevelCacheStatistics</literal>, and <literal>QueryStatistics</literal> API Javadoc for more information. The following code is a simple example:"
+msgstr "你可以直接使用 getter 方法得到全局数据记录（例如，和具体的实体、集合、缓存区无关的数据），你也可以在具体查询中通过标记实体名、 或 HQL、SQL 语句得到某实体的数据记录。请参考 <literal>Statistics</literal>、<literal>EntityStatistics</literal>、<literal>CollectionStatistics</literal>、<literal>SecondLevelCacheStatistics</literal> 和 <literal>QueryStatistics</literal> 的 API 文档以抓取更多信息。下面的代码则是个简单的例子： "
#. Tag: para
#, no-c-format
-msgid ""
-"You can work on all entities, collections, queries and region caches, by "
-"retrieving the list of names of entities, collections, queries and region "
-"caches using the following methods: <literal>getQueries()</literal>, "
-"<literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</"
-"literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
-msgstr ""
-"如果你想得到所有实体、集合、查询和缓存区的数据，你可以通过以下方法获得实体、"
-"集合、查询和缓存区列表：<literal>getQueries()</literal>、"
-"<literal>getEntityNames()</literal>、<literal>getCollectionRoleNames()</"
-"literal> 和 <literal>getSecondLevelCacheRegionNames()</literal>。"
+msgid "You can work on all entities, collections, queries and region caches, by retrieving the list of names of entities, collections, queries and region caches using the following methods: <literal>getQueries()</literal>, <literal>getEntityNames()</literal>, <literal>getCollectionRoleNames()</literal>, and <literal>getSecondLevelCacheRegionNames()</literal>."
+msgstr "如果你想得到所有实体、集合、查询和缓存区的数据，你可以通过以下方法获得实体、集合、查询和缓存区列表：<literal>getQueries()</literal>、<literal>getEntityNames()</literal>、<literal>getCollectionRoleNames()</literal> 和 <literal>getSecondLevelCacheRegionNames()</literal>。"
#~ msgid ""
#~ "<![CDATA[s = sessions.openSession();\n"
@@ -1946,7 +1061,6 @@
#~ "\n"
#~ "Integer accessLevel = (Integer) permissions.get(\"accounts\"); // "
#~ "Error!]]>"
-
#~ msgid ""
#~ "<![CDATA[<set name=\"permissions\" \n"
#~ " fetch=\"join\">\n"
@@ -1959,12 +1073,10 @@
#~ " <key column=\"userId\"/>\n"
#~ " <one-to-many class=\"Permission\"/>\n"
#~ "</set]]>"
-
#~ msgid ""
#~ "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
#~ msgstr ""
#~ "<![CDATA[<many-to-one name=\"mother\" class=\"Cat\" fetch=\"join\"/>]]>"
-
#~ msgid ""
#~ "<![CDATA[User user = (User) session.createCriteria(User.class)\n"
#~ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
@@ -1975,7 +1087,6 @@
#~ " .setFetchMode(\"permissions\", FetchMode.JOIN)\n"
#~ " .add( Restrictions.idEq(userId) )\n"
#~ " .uniqueResult();]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"Cat\" proxy=\"Cat\">\n"
#~ " ......\n"
@@ -1990,7 +1101,6 @@
#~ " .....\n"
#~ " </subclass>\n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // instantiate a "
#~ "proxy (does not hit the db)\n"
@@ -2007,7 +1117,6 @@
#~ " DomesticCat dc = (DomesticCat) cat; // Error!\n"
#~ " ....\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat cat = (Cat) session.load(Cat.class, id); // "
#~ "instantiate a Cat proxy\n"
@@ -2022,14 +1131,12 @@
#~ " (DomesticCat) session.load(DomesticCat.class, id); // acquire "
#~ "new DomesticCat proxy!\n"
#~ "System.out.println(cat==dc); // false]]>"
-
#~ msgid ""
#~ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
#~ "System.out.println( dc.getWeight() ); // 11.0]]>"
#~ msgstr ""
#~ "<![CDATA[cat.setWeight(11.0); // hit the db to initialize the proxy\n"
#~ "System.out.println( dc.getWeight() ); // 11.0]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"CatImpl\" proxy=\"Cat\">\n"
#~ " ......\n"
@@ -2044,7 +1151,6 @@
#~ " .....\n"
#~ " </subclass>\n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat cat = (Cat) session.load(CatImpl.class, catid);\n"
#~ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat."
@@ -2055,24 +1161,20 @@
#~ "Iterator iter = session.createQuery(\"from CatImpl as cat where cat."
#~ "name='fritz'\").iterate();\n"
#~ "Cat fritz = (Cat) iter.next();]]>"
-
#~ msgid ""
#~ "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" )."
#~ "list().get(0) ).intValue()]]>"
#~ msgstr ""
#~ "<![CDATA[( (Integer) s.createFilter( collection, \"select count(*)\" )."
#~ "list().get(0) ).intValue()]]>"
-
#~ msgid ""
#~ "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0)."
#~ "setMaxResults(10).list();]]>"
#~ msgstr ""
#~ "<![CDATA[s.createFilter( lazyCollection, \"\").setFirstResult(0)."
#~ "setMaxResults(10).list();]]>"
-
#~ msgid "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
#~ msgstr "<![CDATA[<class name=\"Person\" batch-size=\"10\">...</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"Person\">\n"
#~ " <set name=\"cats\" batch-size=\"3\">\n"
@@ -2085,7 +1187,6 @@
#~ " ...\n"
#~ " </set>\n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"Document\">\n"
#~ " <id name=\"id\">\n"
@@ -2108,7 +1209,6 @@
#~ " <property name=\"text\" not-null=\"true\" length=\"2000\" lazy=\"true"
#~ "\"/>\n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[<target name=\"instrument\" depends=\"compile\">\n"
#~ " <taskdef name=\"instrument\" classname=\"org.hibernate.tool."
@@ -2139,10 +1239,8 @@
#~ " </fileset>\n"
#~ " </instrument>\n"
#~ "</target>]]>"
-
#~ msgid "<entry>yes</entry>"
#~ msgstr "<entry>yes</entry>"
-
#~ msgid ""
#~ "<![CDATA[<cache \n"
#~ " usage=\"transactional|read-write|nonstrict-read-write|read-only\"\n"
@@ -2155,7 +1253,6 @@
#~ " region=\"RegionName\"\n"
#~ " include=\"all|non-lazy\"\n"
#~ "/>]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"eg.Immutable\" mutable=\"false\">\n"
#~ " <cache usage=\"read-only\"/>\n"
@@ -2166,7 +1263,6 @@
#~ " <cache usage=\"read-only\"/>\n"
#~ " ....\n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[<class name=\"eg.Cat\" .... >\n"
#~ " <cache usage=\"read-write\"/>\n"
@@ -2185,7 +1281,6 @@
#~ " ....\n"
#~ " </set>\n"
#~ "</class>]]>"
-
#~ msgid ""
#~ "<![CDATA[ScrollableResult cats = sess.createQuery(\"from Cat as cat\")."
#~ "scroll(); //a huge result set\n"
@@ -2202,7 +1297,6 @@
#~ " doSomethingWithACat(cat);\n"
#~ " sess.evict(cat);\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[sessionFactory.evict(Cat.class, catId); //evict a particular "
#~ "Cat\n"
@@ -2219,7 +1313,6 @@
#~ "particular collection of kittens\n"
#~ "sessionFactory.evictCollection(\"Cat.kittens\"); //evict all kitten "
#~ "collections]]>"
-
#~ msgid ""
#~ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
#~ " .getSecondLevelCacheStatistics(regionName)\n"
@@ -2228,17 +1321,14 @@
#~ "<![CDATA[Map cacheEntries = sessionFactory.getStatistics()\n"
#~ " .getSecondLevelCacheStatistics(regionName)\n"
#~ " .getEntries();]]>"
-
#~ msgid ""
#~ "<![CDATA[hibernate.generate_statistics true\n"
#~ "hibernate.cache.use_structured_entries true]]>"
#~ msgstr ""
#~ "<![CDATA[hibernate.generate_statistics true\n"
#~ "hibernate.cache.use_structured_entries true]]>"
-
#~ msgid "<![CDATA[hibernate.cache.use_query_cache true]]>"
#~ msgstr "<![CDATA[hibernate.cache.use_query_cache true]]>"
-
#~ msgid ""
#~ "<![CDATA[List blogs = sess.createQuery(\"from Blog blog where blog."
#~ "blogger = :blogger\")\n"
@@ -2255,7 +1345,6 @@
#~ " .setCacheable(true)\n"
#~ " .setCacheRegion(\"frontpages\")\n"
#~ " .list();]]>"
-
#~ msgid ""
#~ "<![CDATA[Parent p = (Parent) sess.load(Parent.class, id);\n"
#~ "Child c = new Child();\n"
@@ -2268,7 +1357,6 @@
#~ "c.setParent(p);\n"
#~ "p.getChildren().add(c); //no need to fetch the collection!\n"
#~ "sess.flush();]]>"
-
#~ msgid ""
#~ "<![CDATA[// MBean service registration for a specific SessionFactory\n"
#~ "Hashtable tb = new Hashtable();\n"
@@ -2293,7 +1381,6 @@
#~ "stats.setSessionFactory(sessionFactory); // Bind the stats to a "
#~ "SessionFactory\n"
#~ "server.registerMBean(stats, on); // Register the Mbean on the server]]>"
-
#~ msgid ""
#~ "<![CDATA[// MBean service registration for all SessionFactory's\n"
#~ "Hashtable tb = new Hashtable();\n"
@@ -2314,7 +1401,6 @@
#~ "StatisticsService stats = new StatisticsService(); // MBean "
#~ "implementation\n"
#~ "server.registerMBean(stats, on); // Register the MBean on the server]]>"
-
#~ msgid ""
#~ "<![CDATA[Statistics stats = HibernateUtil.sessionFactory.getStatistics"
#~ "();\n"
@@ -2351,3 +1437,4 @@
#~ " + entityStats.getUpdateCount()\n"
#~ " + entityStats.getDeleteCount();\n"
#~ "log.info(Cat.class.getName() + \" changed \" + changes + \"times\" );]]>"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/persistent_classes.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/persistent_classes.po 2009-12-07 10:21:17 UTC (rev 97494)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/persistent_classes.po 2009-12-07 11:14:45 UTC (rev 97495)
@@ -7,7 +7,7 @@
"Project-Id-Version: persistent_classes\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2009-11-24 10:44+1000\n"
+"PO-Revision-Date: 2009-12-07 09:36+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,30 +22,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Persistent classes are classes in an application that implement the entities "
-"of the business problem (e.g. Customer and Order in an E-commerce "
-"application). Not all instances of a persistent class are considered to be "
-"in the persistent state. For example, an instance can instead be transient "
-"or detached."
-msgstr ""
-"在应用程序中，用来实现业务问题实体的（如，在电子商务应用程序中的 Customer 和 "
-"Order）类就是持久化类。不能认为所有的持久化类的实例都是持久的状态 - 一个实例"
-"的状态也可能是瞬时的或脱管的。"
+msgid "Persistent classes are classes in an application that implement the entities of the business problem (e.g. Customer and Order in an E-commerce application). Not all instances of a persistent class are considered to be in the persistent state. For example, an instance can instead be transient or detached."
+msgstr "在应用程序中，用来实现业务问题实体的（如，在电子商务应用程序中的 Customer 和 Order）类就是持久化类。不能认为所有的持久化类的实例都是持久的状态 - 一个实例的状态也可能是瞬时的或脱管的。"
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate works best if these classes follow some simple rules, also known "
-"as the Plain Old Java Object (POJO) programming model. However, none of "
-"these rules are hard requirements. Indeed, Hibernate3 assumes very little "
-"about the nature of your persistent objects. You can express a domain model "
-"in other ways (using trees of <literal>Map</literal> instances, for example)."
-msgstr ""
-"如果这些持久化类遵循一些简单的规则，Hibernate 能够工作得更好，这些规则也被称"
-"作简单传统 Java 对象（POJO:Plain Old Java Object）编程模型。但是这些规则并不"
-"是必需的。 实际上，Hibernate3 对于你的持久化类几乎不做任何设想。你可以用其他"
-"的方法来表达领域模型：比如，使用 <literal>Map</literal> 实例的树型结构。"
+msgid "Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. However, none of these rules are hard requirements. Indeed, Hibernate3 assumes very little about the nature of your persistent objects. You can express a domain model in other ways (using trees of <literal>Map</literal> instances, for example)."
+msgstr "如果这些持久化类遵循一些简单的规则，Hibernate 能够工作得更好，这些规则也被称作简单传统 Java 对象（POJO:Plain Old Java Object）编程模型。但是这些规则并不是必需的。 实际上，Hibernate3 对于你的持久化类几乎不做任何设想。你可以用其他的方法来表达领域模型：比如，使用 <literal>Map</literal> 实例的树型结构。"
#. Tag: title
#, no-c-format
@@ -54,16 +37,12 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Most Java applications require a persistent class representing felines. For "
-"example:"
+msgid "Most Java applications require a persistent class representing felines. For example:"
msgstr "大多数 Java 程序需要用一个持久化类来表示猫科动物。例如："
#. Tag: para
#, no-c-format
-msgid ""
-"The four main rules of persistent classes are explored in more detail in the "
-"following sections."
+msgid "The four main rules of persistent classes are explored in more detail in the following sections."
msgstr "在后续的章节里我们将介绍持久性类的 4 个主要规则的更多细节。"
#. Tag: title
@@ -73,19 +52,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>Cat</literal> has a no-argument constructor. All persistent classes "
-"must have a default constructor (which can be non-public) so that Hibernate "
-"can instantiate them using <literal>Constructor.newInstance()</literal>. It "
-"is recommended that you have a default constructor with at least "
-"<emphasis>package</emphasis> visibility for runtime proxy generation in "
-"Hibernate."
-msgstr ""
-"<literal>Cat</literal> 有一个无参数的构造方法。所有的持久化类都必须有一个默认"
-"的构造方法（可以不是 public 的），这样的话 Hibernate 就可以使用 "
-"<literal>Constructor.newInstance(）</literal>来实例化它们。 我们强烈建议，在 "
-"Hibernate 中，为了运行期代理的生成，构造方法至少是<emphasis>包（package）</"
-"emphasis>内可见的。"
+msgid "<literal>Cat</literal> has a no-argument constructor. All persistent classes must have a default constructor (which can be non-public) so that Hibernate can instantiate them using <literal>Constructor.newInstance()</literal>. It is recommended that you have a default constructor with at least <emphasis>package</emphasis> visibility for runtime proxy generation in Hibernate."
+msgstr "<literal>Cat</literal> 有一个无参数的构造方法。所有的持久化类都必须有一个默认的构造方法（可以不是 public 的），这样的话 Hibernate 就可以使用 <literal>Constructor.newInstance(）</literal>来实例化它们。 我们强烈建议，在 Hibernate 中，为了运行期代理的生成，构造方法至少是<emphasis>包（package）</emphasis>内可见的。"
#. Tag: title
#, no-c-format
@@ -94,65 +62,38 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>Cat</literal> has a property called <literal>id</literal>. This "
-"property maps to the primary key column of a database table. The property "
-"might have been called anything, and its type might have been any primitive "
-"type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or "
-"<literal>java.util.Date</literal>. If your legacy database table has "
-"composite keys, you can use a user-defined class with properties of these "
-"types (see the section on composite identifiers later in the chapter.)"
-msgstr ""
-"<literal>Cat</literal> 有一个属性叫做 <literal>id</literal>。这个属性映射数据"
-"库表的主 键字段。这个属性可以叫任何名字，其类型可以是任何的原始类型、原始类型"
-"的包装类型、 <literal>java.lang.String</literal> 或者是 <literal>java.util."
-"Date</literal>。（如果你的遗留数据库表有联合主键，你甚至可以用一个用户自定义"
-"的类，该类拥有这些类型的属性。参见后面的关于联合标识符的章节。）"
+msgid "<literal>Cat</literal> has a property called <literal>id</literal>. This property maps to the primary key column of a database table. The property might have been called anything, and its type might have been any primitive type, any primitive \"wrapper\" type, <literal>java.lang.String</literal> or <literal>java.util.Date</literal>. If your legacy database table has composite keys, you can use a user-defined class with properties of these types (see the section on composite identifiers later in the chapter.)"
+msgstr "<literal>Cat</literal> 有一个属性叫做 <literal>id</literal>。这个属性映射数据库表的主 键字段。这个属性可以叫任何名字，其类型可以是任何的原始类型、原始类型的包装类型、 <literal>java.lang.String</literal> 或者是 <literal>java.util.Date</literal>。（如果你的遗留数据库表有联合主键，你甚至可以用一个用户自定义的类，该类拥有这些类型的属性。参见后面的关于联合标识符的章节。）"
#. Tag: para
#, no-c-format
-msgid ""
-"The identifier property is strictly optional. You can leave them off and let "
-"Hibernate keep track of object identifiers internally. We do not recommend "
-"this, however."
-msgstr ""
-"标识符属性是可选的。可以不用管它，让 Hibernate 内部来追踪对象的识别。 但是我"
-"们并不推荐这样做。"
+msgid "The identifier property is strictly optional. You can leave them off and let Hibernate keep track of object identifiers internally. We do not recommend this, however."
+msgstr "标识符属性是可选的。可以不用管它，让 Hibernate 内部来追踪对象的识别。 但是我们并不推荐这样做。"
#. Tag: para
#, no-c-format
-msgid ""
-"In fact, some functionality is available only to classes that declare an "
-"identifier property:"
+msgid "In fact, some functionality is available only to classes that declare an identifier property:"
msgstr "实际上，一些功能只对那些声明了标识符属性的类起作用： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Transitive reattachment for detached objects (cascade update or cascade "
-"merge) - see <xref linkend=\"objectstate-transitive\" />"
-msgstr ""
-"托管对象的传播性再连接（级联更新或级联合并） — 参阅 <xref linkend="
-"\"objectstate-transitive\"/> "
+#, no-c-format
+msgid "Transitive reattachment for detached objects (cascade update or cascade merge) - see <xref linkend=\"objectstate-transitive\" />"
+msgstr "托管对象的传播性再连接（级联更新或级联合并） — 参阅 <xref linkend=\"objectstate-transitive\"/>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>Session.saveOrUpdate()</literal>"
-msgstr "Session.saveOrUpdate()"
+msgstr "<literal>Session.saveOrUpdate()</literal>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>Session.merge()</literal>"
-msgstr "Session.merge()"
+msgstr "<literal>Session.merge()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"We recommend that you declare consistently-named identifier properties on "
-"persistent classes and that you use a nullable (i.e., non-primitive) type."
-msgstr ""
-"我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一个可以为空（也"
-"就是说，不是原始类型）的类型。 "
+msgid "We recommend that you declare consistently-named identifier properties on persistent classes and that you use a nullable (i.e., non-primitive) type."
+msgstr "我们建议你对持久化类声明命名一致的标识属性。我们还建议你使用一个可以为空（也就是说，不是原始类型）的类型。 "
#. Tag: title
#, no-c-format
@@ -161,72 +102,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon "
-"the persistent class being either non-final, or the implementation of an "
-"interface that declares all public methods."
-msgstr ""
-"<emphasis>代理（proxies）</emphasis>是 Hibernate 的一个重要的功能，它依赖的条"
-"件是，持久化类或者是非 final 的，或者是实现了一个所有方法都声明为 public 的接"
-"口。"
+msgid "A central feature of Hibernate, <emphasis>proxies</emphasis>, depends upon the persistent class being either non-final, or the implementation of an interface that declares all public methods."
+msgstr "<emphasis>代理（proxies）</emphasis>是 Hibernate 的一个重要的功能，它依赖的条件是，持久化类或者是非 final 的，或者是实现了一个所有方法都声明为 public 的接口。"
#. Tag: para
#, no-c-format
-msgid ""
-"You can persist <literal>final</literal> classes that do not implement an "
-"interface with Hibernate. You will not, however, be able to use proxies for "
-"lazy association fetching which will ultimately limit your options for "
-"performance tuning."
-msgstr ""
-"你可以用 Hibernate 持久化一个没有实现任何接口的 <literal>final</literal> 类，"
-"但是你不能使用代理来延迟关联加载，这会限制你进行性能优化的选择。 "
+msgid "You can persist <literal>final</literal> classes that do not implement an interface with Hibernate. You will not, however, be able to use proxies for lazy association fetching which will ultimately limit your options for performance tuning."
+msgstr "你可以用 Hibernate 持久化一个没有实现任何接口的 <literal>final</literal> 类，但是你不能使用代理来延迟关联加载，这会限制你进行性能优化的选择。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You should also avoid declaring <literal>public final</literal> methods on "
-"the non-final classes. If you want to use a class with a <literal>public "
-"final</literal> method, you must explicitly disable proxying by setting "
-"<literal>lazy=\"false\"</literal>."
-msgstr ""
-"你也应该避免在非 final 类中声明 <literal>public final</literal> 的方法。如果"
-"你想使用一个有 <literal>public final</literal> 方法的类，你必须通过设置 "
-"<literal>lazy=\"false\"</literal> 来明确地禁用代理。 "
+msgid "You should also avoid declaring <literal>public final</literal> methods on the non-final classes. If you want to use a class with a <literal>public final</literal> method, you must explicitly disable proxying by setting <literal>lazy=\"false\"</literal>."
+msgstr "你也应该避免在非 final 类中声明 <literal>public final</literal> 的方法。如果你想使用一个有 <literal>public final</literal> 方法的类，你必须通过设置 <literal>lazy=\"false\"</literal> 来明确地禁用代理。 "
#. Tag: title
#, no-c-format
msgid "Declare accessors and mutators for persistent fields (optional)"
-msgstr ""
-"为持久化字段声明访问器（accessors）和是否可变的标志（mutators）（可选）"
+msgstr "为持久化字段声明访问器（accessors）和是否可变的标志（mutators）（可选）"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>Cat</literal> declares accessor methods for all its persistent "
-"fields. Many other ORM tools directly persist instance variables. It is "
-"better to provide an indirection between the relational schema and internal "
-"data structures of the class. By default, Hibernate persists JavaBeans style "
-"properties and recognizes method names of the form <literal>getFoo</"
-"literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. If "
-"required, you can switch to direct field access for particular properties."
-msgstr ""
-"<literal>Cat</literal> 为它的所有持久化字段声明了访问方法。很多其他 ORM 工具"
-"直接对实例变量进行持久化。我们相信，在关系数据库 schema 和类的内部数据结构之"
-"间引入间接层（原文为\"非直接\"，indirection）会好一些。默认情况下 Hibernate "
-"持久化 JavaBeans 风格的属性，认可 <literal>getFoo</literal>，"
-"<literal>isFoo</literal> 和 <literal>setFoo</literal> 这种形式的方法名。如果"
-"需要，你可以对某些特定属性实行直接字段访问。 "
+msgid "<literal>Cat</literal> declares accessor methods for all its persistent fields. Many other ORM tools directly persist instance variables. It is better to provide an indirection between the relational schema and internal data structures of the class. By default, Hibernate persists JavaBeans style properties and recognizes method names of the form <literal>getFoo</literal>, <literal>isFoo</literal> and <literal>setFoo</literal>. If required, you can switch to direct field access for particular properties."
+msgstr "<literal>Cat</literal> 为它的所有持久化字段声明了访问方法。很多其他 ORM 工具直接对实例变量进行持久化。我们相信，在关系数据库 schema 和类的内部数据结构之间引入间接层（原文为\"非直接\"，indirection）会好一些。默认情况下 Hibernate 持久化 JavaBeans 风格的属性，认可 <literal>getFoo</literal>，<literal>isFoo</literal> 和 <literal>setFoo</literal> 这种形式的方法名。如果需要，你可以对某些特定属性实行直接字段访问。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Properties need <emphasis>not</emphasis> be declared public - Hibernate can "
-"persist a property with a default, <literal>protected</literal> or "
-"<literal>private</literal> get / set pair."
-msgstr ""
-"属性<emphasis>不需要</emphasis>要声明为 public 的。Hibernate 可以持久化一个"
-"有 <literal>default</literal>、<literal>protected</literal> 或 "
-"<literal>private</literal> 的 get/set 方法对的属性进行持久化。"
+msgid "Properties need <emphasis>not</emphasis> be declared public - Hibernate can persist a property with a default, <literal>protected</literal> or <literal>private</literal> get / set pair."
+msgstr "属性<emphasis>不需要</emphasis>要声明为 public 的。Hibernate 可以持久化一个有 <literal>default</literal>、<literal>protected</literal> 或 <literal>private</literal> 的 get/set 方法对的属性进行持久化。"
#. Tag: title
#, no-c-format
@@ -235,38 +137,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A subclass must also observe the first and second rules. It inherits its "
-"identifier property from the superclass, <literal>Cat</literal>. For example:"
-msgstr ""
-"子类也必须遵守第一条和第二条规则。它从超类 <literal>Cat</literal> 继承了标识"
-"属性。例如："
+msgid "A subclass must also observe the first and second rules. It inherits its identifier property from the superclass, <literal>Cat</literal>. For example:"
+msgstr "子类也必须遵守第一条和第二条规则。它从超类 <literal>Cat</literal> 继承了标识属性。例如："
#. Tag: title
#, no-c-format
-msgid ""
-"Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
-msgstr ""
-"实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法："
+msgid "Implementing <literal>equals()</literal> and <literal>hashCode()</literal>"
+msgstr "实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法："
#. Tag: para
#, no-c-format
-msgid ""
-"You have to override the <literal>equals()</literal> and <literal>hashCode()"
-"</literal> methods if you:"
-msgstr ""
-"如果你有如下需求，你必须重载 <literal>equals()</literal> 和 <literal>hashCode"
-"()</literal> 方法： "
+msgid "You have to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods if you:"
+msgstr "如果你有如下需求，你必须重载 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法： "
#. Tag: para
#, no-c-format
-msgid ""
-"intend to put instances of persistent classes in a <literal>Set</literal> "
-"(the recommended way to represent many-valued associations); <emphasis>and</"
-"emphasis>"
-msgstr ""
-"想把持久类的实例放入 <literal>Set</literal> 中（当表示多值关联时，推荐这么"
-"做），<emphasis>而且</emphasis>"
+msgid "intend to put instances of persistent classes in a <literal>Set</literal> (the recommended way to represent many-valued associations); <emphasis>and</emphasis>"
+msgstr "想把持久类的实例放入 <literal>Set</literal> 中（当表示多值关联时，推荐这么做），<emphasis>而且</emphasis>"
#. Tag: para
#, no-c-format
@@ -275,73 +162,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate guarantees equivalence of persistent identity (database row) and "
-"Java identity only inside a particular session scope. When you mix instances "
-"retrieved in different sessions, you must implement <literal>equals()</"
-"literal> and <literal>hashCode()</literal> if you wish to have meaningful "
-"semantics for <literal>Set</literal>s."
-msgstr ""
-"Hibernate 保证，仅在特定会话范围内，持久化标识（数据库的行）和 Java 标识是等"
-"价的。因此，一旦我们混合了从不同会话中获取的实例，如果希望 <literal>Set</"
-"literal> 有明确的语义，就必须实现 <literal>equals()</literal> 和 "
-"<literal>hashCode()</literal>。 "
+msgid "Hibernate guarantees equivalence of persistent identity (database row) and Java identity only inside a particular session scope. When you mix instances retrieved in different sessions, you must implement <literal>equals()</literal> and <literal>hashCode()</literal> if you wish to have meaningful semantics for <literal>Set</literal>s."
+msgstr "Hibernate 保证，仅在特定会话范围内，持久化标识（数据库的行）和 Java 标识是等价的。因此，一旦我们混合了从不同会话中获取的实例，如果希望 <literal>Set</literal> 有明确的语义，就必须实现 <literal>equals()</literal> 和 <literal>hashCode()</literal>。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The most obvious way is to implement <literal>equals()</literal>/"
-"<literal>hashCode()</literal> by comparing the identifier value of both "
-"objects. If the value is the same, both must be the same database row, "
-"because they are equal. If both are added to a <literal>Set</literal>, you "
-"will only have one element in the <literal>Set</literal>). Unfortunately, "
-"you cannot use that approach with generated identifiers. Hibernate will only "
-"assign identifier values to objects that are persistent; a newly created "
-"instance will not have any identifier value. Furthermore, if an instance is "
-"unsaved and currently in a <literal>Set</literal>, saving it will assign an "
-"identifier value to the object. If <literal>equals()</literal> and "
-"<literal>hashCode()</literal> are based on the identifier value, the hash "
-"code would change, breaking the contract of the <literal>Set</literal>. See "
-"the Hibernate website for a full discussion of this problem. This is not a "
-"Hibernate issue, but normal Java semantics of object identity and equality."
-msgstr ""
-"实现 <literal>equals()</literal>/<literal>hashCode()</literal> 最显而易见的方"
-"法是比较两个对象 标识符的值。如果值相同，则两个对象对应于数据库的同一行，因此"
-"它们是相等的（如果都被添加到 <literal>Set</literal>，则在 <literal>Set</"
-"literal> 中只有一个元素）。不幸的是，对生成的标识不能 使用这种方法。"
-"Hibernate 仅对那些持久化对象赋标识值，一个新创建的实例将不会有任何标识值。此"
-"外， 如果一个实例没有被保存（unsaved），并且它当前正在一个 <literal>Set</"
-"literal> 中，保存它将会给这个对象赋一个标识值。如果 <literal>equals()</"
-"literal> 和 <literal>hashCode()</literal> 是基于标识值 实现的，则其哈希码将会"
-"改变，这违反了 <literal>Set</literal> 的契约。建议去 Hibernate 的站点阅读关于"
-"这个问题的全部讨论。注意，这不是 Hibernate 的问题，而是一般的 Java 对象标识"
-"和 Java 对象等价的语义问题。 "
+msgid "The most obvious way is to implement <literal>equals()</literal>/<literal>hashCode()</literal> by comparing the identifier value of both objects. If the value is the same, both must be the same database row, because they are equal. If both are added to a <literal>Set</literal>, you will only have one element in the <literal>Set</literal>). Unfortunately, you cannot use that approach with generated identifiers. Hibernate will only assign identifier values to objects that are persistent; a newly created instance will not have any identifier value. Furthermore, if an instance is unsaved and currently in a <literal>Set</literal>, saving it will assign an identifier value to the object. If <literal>equals()</literal> and <literal>hashCode()</literal> are based on the identifier value, the hash code would change, breaking the contract of the <literal>Set</literal>. See the Hibernate website for a full discussion of this problem. This is not a Hibernate issue, but normal Ja!
va semantics of object identity and equality."
+msgstr "实现 <literal>equals()</literal>/<literal>hashCode()</literal> 最显而易见的方法是比较两个对象 标识符的值。如果值相同，则两个对象对应于数据库的同一行，因此它们是相等的（如果都被添加到 <literal>Set</literal>，则在 <literal>Set</literal> 中只有一个元素）。不幸的是，对生成的标识不能 使用这种方法。Hibernate 仅对那些持久化对象赋标识值，一个新创建的实例将不会有任何标识值。此外， 如果一个实例没有被保存（unsaved），并且它当前正在一个 <literal>Set</literal> 中，保存它将会给这个对象赋一个标识值。如果 <literal>equals()</literal> 和 <literal>hashCode()</literal> 是基于标识值 实现的，则其哈希码将会改变，这违反了 <literal>Set</literal> 的契约。建议去 Hibernate 的站点阅读关于这个问题的全部讨论。注意，这不是 Hibernate 的问题，而是一般的 Java 对象标!
识和 Java 对象等价的语义问题。 "
#. Tag: para
#, no-c-format
-msgid ""
-"It is recommended that you implement <literal>equals()</literal> and "
-"<literal>hashCode()</literal> using <emphasis>Business key equality</"
-"emphasis>. Business key equality means that the <literal>equals()</literal> "
-"method compares only the properties that form the business key. It is a key "
-"that would identify our instance in the real world (a <emphasis>natural</"
-"emphasis> candidate key):"
-msgstr ""
-"我们建议使用<emphasis>业务键值相等（Business key equality）</emphasis>来实现 "
-"<literal>equals()</literal> 和 <literal>hashCode()</literal>。业务键值相等的"
-"意思是，<literal>equals()</literal> 方法仅仅比较形成业务键的属性，它能在现实"
-"世界里标识我们的实例（是一个<emphasis>自然的</emphasis>候选码）。"
+msgid "It is recommended that you implement <literal>equals()</literal> and <literal>hashCode()</literal> using <emphasis>Business key equality</emphasis>. Business key equality means that the <literal>equals()</literal> method compares only the properties that form the business key. It is a key that would identify our instance in the real world (a <emphasis>natural</emphasis> candidate key):"
+msgstr "我们建议使用<emphasis>业务键值相等（Business key equality）</emphasis>来实现 <literal>equals()</literal> 和 <literal>hashCode()</literal>。业务键值相等的意思是，<literal>equals()</literal> 方法仅仅比较形成业务键的属性，它能在现实世界里标识我们的实例（是一个<emphasis>自然的</emphasis>候选码）。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A business key does not have to be as solid as a database primary key "
-"candidate (see <xref linkend=\"transactions-basics-identity\" />). Immutable "
-"or unique properties are usually good candidates for a business key."
-msgstr ""
-"注意，业务键不必像数据库的主键那样固定不变（参见 <xref linkend="
-"\"transactions-basics-identity\"/>）。对业务键而言，不可变或唯一的属性是不错"
-"的选择。"
+#, no-c-format
+msgid "A business key does not have to be as solid as a database primary key candidate (see <xref linkend=\"transactions-basics-identity\" />). Immutable or unique properties are usually good candidates for a business key."
+msgstr "注意，业务键不必像数据库的主键那样固定不变（参见 <xref linkend=\"transactions-basics-identity\"/>）。对业务键而言，不可变或唯一的属性是不错的选择。 "
#. Tag: title
#, no-c-format
@@ -354,116 +191,54 @@
msgstr "注意"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>The following features are currently considered experimental and "
-"may change in the near future.</emphasis>"
-msgstr "注意，以下特性在当前处于试验阶段，将来可能会有变化。 "
+#, no-c-format
+msgid "<emphasis>The following features are currently considered experimental and may change in the near future.</emphasis>"
+msgstr "<emphasis>注意，以下特性在当前处于试验阶段，将来可能会有变化。</emphasis>"
#. Tag: para
#, no-c-format
-msgid ""
-"Persistent entities do not necessarily have to be represented as POJO "
-"classes or as JavaBean objects at runtime. Hibernate also supports dynamic "
-"models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) "
-"and the representation of entities as DOM4J trees. With this approach, you "
-"do not write persistent classes, only mapping files."
-msgstr ""
-"运行期的持久化实体没有必要一定表示为像 POJO 类或 JavaBean 对象那样的形式。"
-"Hibernate 也支持动态模型 （在运行期使用 <literal>Map</literal> 的 "
-"<literal>Map</literal>）和象 DOM4J 的树模型那样的实体表示。使用这种方法，你不"
-"用写持久化类，只写映射文件就行了。 "
+msgid "Persistent entities do not necessarily have to be represented as POJO classes or as JavaBean objects at runtime. Hibernate also supports dynamic models (using <literal>Map</literal>s of <literal>Map</literal>s at runtime) and the representation of entities as DOM4J trees. With this approach, you do not write persistent classes, only mapping files."
+msgstr "运行期的持久化实体没有必要一定表示为像 POJO 类或 JavaBean 对象那样的形式。Hibernate 也支持动态模型 （在运行期使用 <literal>Map</literal> 的 <literal>Map</literal>）和象 DOM4J 的树模型那样的实体表示。使用这种方法，你不用写持久化类，只写映射文件就行了。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"By default, Hibernate works in normal POJO mode. You can set a default "
-"entity representation mode for a particular <literal>SessionFactory</"
-"literal> using the <literal>default_entity_mode</literal> configuration "
-"option (see <xref linkend=\"configuration-optional-properties\" />)."
-msgstr ""
-"Hibernate 默认工作在普通 POJO 模式。你可以使用配置选项 "
-"<literal>default_entity_mode</literal>， 对特定的 <literal>SessionFactory</"
-"literal>，设置一个默认的实体表示模式。（参见 <xref linkend=\"configuration-"
-"optional-properties\"/>）"
+#, no-c-format
+msgid "By default, Hibernate works in normal POJO mode. You can set a default entity representation mode for a particular <literal>SessionFactory</literal> using the <literal>default_entity_mode</literal> configuration option (see <xref linkend=\"configuration-optional-properties\" />)."
+msgstr "Hibernate 默认工作在普通 POJO 模式。你可以使用配置选项 <literal>default_entity_mode</literal>， 对特定的 <literal>SessionFactory</literal>，设置一个默认的实体表示模式。（参见 <xref linkend=\"configuration-optional-properties\"/>） "
#. Tag: para
#, no-c-format
-msgid ""
-"The following examples demonstrate the representation using <literal>Map</"
-"literal>s. First, in the mapping file an <literal>entity-name</literal> has "
-"to be declared instead of, or in addition to, a class name:"
-msgstr ""
-"下面是用 <literal>Map</literal> 来表示的例子。首先，在映射文件中，要声明 "
-"<literal>entity-name</literal> 来代替一个类名（或作为一种附属）。 "
+msgid "The following examples demonstrate the representation using <literal>Map</literal>s. First, in the mapping file an <literal>entity-name</literal> has to be declared instead of, or in addition to, a class name:"
+msgstr "下面是用 <literal>Map</literal> 来表示的例子。首先，在映射文件中，要声明 <literal>entity-name</literal> 来代替一个类名（或作为一种附属）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Even though associations are declared using target class names, the target "
-"type of associations can also be a dynamic entity instead of a POJO."
-msgstr ""
-"注意，虽然是用目标类名来声明关联的，但是关联的目标类型除了是 POJO 之外，也可"
-"以是一个动态的实体。 "
+msgid "Even though associations are declared using target class names, the target type of associations can also be a dynamic entity instead of a POJO."
+msgstr "注意，虽然是用目标类名来声明关联的，但是关联的目标类型除了是 POJO 之外，也可以是一个动态的实体。 "
#. Tag: para
#, no-c-format
-msgid ""
-"After setting the default entity mode to <literal>dynamic-map</literal> for "
-"the <literal>SessionFactory</literal>, you can, at runtime, work with "
-"<literal>Map</literal>s of <literal>Map</literal>s:"
-msgstr ""
-"在使用 <literal>dynamic-map</literal> 为 <literal>SessionFactory</literal> 设"
-"置了默认的实体模式之后，可以在运行期使用 <literal>Map</literal> 的 "
-"<literal>Map</literal>："
+msgid "After setting the default entity mode to <literal>dynamic-map</literal> for the <literal>SessionFactory</literal>, you can, at runtime, work with <literal>Map</literal>s of <literal>Map</literal>s:"
+msgstr "在使用 <literal>dynamic-map</literal> 为 <literal>SessionFactory</literal> 设置了默认的实体模式之后，可以在运行期使用 <literal>Map</literal> 的 <literal>Map</literal>："
#. Tag: para
#, no-c-format
-msgid ""
-"One of the main advantages of dynamic mapping is quick turnaround time for "
-"prototyping, without the need for entity class implementation. However, you "
-"lose compile-time type checking and will likely deal with many exceptions at "
-"runtime. As a result of the Hibernate mapping, the database schema can "
-"easily be normalized and sound, allowing to add a proper domain model "
-"implementation on top later on."
-msgstr ""
-"动态映射的好处是，变化所需要的时间少了，因为原型不需要实现实体类。然而，你无"
-"法进行编译期的类型检查，并可能由此会处理很多的运行期异常。幸亏有了 Hibernate "
-"映射，它使得数据库的 schema 能容易的规格化和合理化，并允许稍后在此之上添加合"
-"适的领域模型实现。 "
+msgid "One of the main advantages of dynamic mapping is quick turnaround time for prototyping, without the need for entity class implementation. However, you lose compile-time type checking and will likely deal with many exceptions at runtime. As a result of the Hibernate mapping, the database schema can easily be normalized and sound, allowing to add a proper domain model implementation on top later on."
+msgstr "动态映射的好处是，变化所需要的时间少了，因为原型不需要实现实体类。然而，你无法进行编译期的类型检查，并可能由此会处理很多的运行期异常。幸亏有了 Hibernate 映射，它使得数据库的 schema 能容易的规格化和合理化，并允许稍后在此之上添加合适的领域模型实现。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Entity representation modes can also be set on a per <literal>Session</"
-"literal> basis:"
+msgid "Entity representation modes can also be set on a per <literal>Session</literal> basis:"
msgstr "实体表示模式也能在每个 <literal>Session</literal> 的基础上设置："
#. Tag: para
#, no-c-format
-msgid ""
-"Please note that the call to <literal>getSession()</literal> using an "
-"<literal>EntityMode</literal> is on the <literal>Session</literal> API, not "
-"the <literal>SessionFactory</literal>. That way, the new <literal>Session</"
-"literal> shares the underlying JDBC connection, transaction, and other "
-"context information. This means you do not have to call <literal>flush()</"
-"literal> and <literal>close()</literal> on the secondary <literal>Session</"
-"literal>, and also leave the transaction and connection handling to the "
-"primary unit of work."
-msgstr ""
-"请注意，用 <literal>EntityMode</literal> 调用 <literal>getSession()</"
-"literal> 是在 <literal>Session</literal> 的 API 中，而不是 "
-"<literal>SessionFactory</literal>。 这样，新的 <literal>Session</literal> 共"
-"享底层的 JDBC 连接，事务，和其他的上下文信息。这意味着，你不需要在第二个 "
-"<literal>Session</literal> 中调用 <literal>flush()</literal> 和 "
-"<literal>close()</literal>，同样的，把事务和连接的处理交给原来的工作单元。 "
+msgid "Please note that the call to <literal>getSession()</literal> using an <literal>EntityMode</literal> is on the <literal>Session</literal> API, not the <literal>SessionFactory</literal>. That way, the new <literal>Session</literal> shares the underlying JDBC connection, transaction, and other context information. This means you do not have to call <literal>flush()</literal> and <literal>close()</literal> on the secondary <literal>Session</literal>, and also leave the transaction and connection handling to the primary unit of work."
+msgstr "请注意，用 <literal>EntityMode</literal> 调用 <literal>getSession()</literal> 是在 <literal>Session</literal> 的 API 中，而不是 <literal>SessionFactory</literal>。 这样，新的 <literal>Session</literal> 共享底层的 JDBC 连接，事务，和其他的上下文信息。这意味着，你不需要在第二个 <literal>Session</literal> 中调用 <literal>flush()</literal> 和 <literal>close()</literal>，同样的，把事务和连接的处理交给原来的工作单元。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"More information about the XML representation capabilities can be found in "
-"<xref linkend=\"xml\" />."
-msgstr "关于 XML 表示能力的更多信息可以在 <xref linkend=\"xml\"/> 中找到。"
+#, no-c-format
+msgid "More information about the XML representation capabilities can be found in <xref linkend=\"xml\" />."
+msgstr "关于 XML 表示能力的更多信息可以在 <xref linkend=\"xml\"/> 中找到。 "
#. Tag: title
#, no-c-format
@@ -472,61 +247,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are "
-"responsible for managing a particular representation of a piece of data "
-"given that representation's <literal>org.hibernate.EntityMode</literal>. If "
-"a given piece of data is thought of as a data structure, then a tuplizer is "
-"the thing that knows how to create such a data structure and how to extract "
-"values from and inject values into such a data structure. For example, for "
-"the POJO entity mode, the corresponding tuplizer knows how create the POJO "
-"through its constructor. It also knows how to access the POJO properties "
-"using the defined property accessors."
-msgstr ""
-"<literal>org.hibernate.tuple.Tuplizer</literal>，以及其子接口，负责根据给定的"
-"<literal>org.hibernate.EntityMode</literal>，来复现片断数据。如果给定的片断数"
-"据被认为其是一种数据结构，\"tuplizer\" 就是一个知道如何创建这样的数据结构，以"
-"及如何给这个数据结构赋值的东西。比如说，对于 POJO 这种 Entity Mode，对应的 "
-"tuplizer 知道通过其构造方法来创建一个 POJO，再通过其属性访问器来访问 POJO 属"
-"性。有两大类高层 Tuplizer，分别是<literal>org.hibernate.tuple.entity."
-"EntityTuplizer</literal> 和 <literal>org.hibernate.tuple.entity."
-"ComponentTuplizer</literal> 接口。<literal>EntityTuplizer</literal> 负责管理"
-"上面提到的实体的契约，而 <literal>ComponentTuplizer</literal> 则是针对组件"
-"的。 "
+msgid "<literal>org.hibernate.tuple.Tuplizer</literal>, and its sub-interfaces, are responsible for managing a particular representation of a piece of data given that representation's <literal>org.hibernate.EntityMode</literal>. If a given piece of data is thought of as a data structure, then a tuplizer is the thing that knows how to create such a data structure and how to extract values from and inject values into such a data structure. For example, for the POJO entity mode, the corresponding tuplizer knows how create the POJO through its constructor. It also knows how to access the POJO properties using the defined property accessors."
+msgstr "<literal>org.hibernate.tuple.Tuplizer</literal>，以及其子接口，负责根据给定的<literal>org.hibernate.EntityMode</literal>，来复现片断数据。如果给定的片断数据被认为其是一种数据结构，\"tuplizer\" 就是一个知道如何创建这样的数据结构，以及如何给这个数据结构赋值的东西。比如说，对于 POJO 这种 Entity Mode，对应的 tuplizer 知道通过其构造方法来创建一个 POJO，再通过其属性访问器来访问 POJO 属性。有两大类高层 Tuplizer，分别是<literal>org.hibernate.tuple.entity.EntityTuplizer</literal> 和 <literal>org.hibernate.tuple.entity.ComponentTuplizer</literal> 接口。<literal>EntityTuplizer</literal> 负责管理上面提到的实体的契约，而 <literal>ComponentTuplizer</literal> 则是针对组件的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"There are two high-level types of Tuplizers, represented by the <literal>org."
-"hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate."
-"tuple.component.ComponentTuplizer</literal> interfaces. "
-"<literal>EntityTuplizer</literal>s are responsible for managing the above "
-"mentioned contracts in regards to entities, while "
-"<literal>ComponentTuplizer</literal>s do the same for components."
-msgstr ""
-"有两种高层类型的 Tuplizer，分别由 <literal>org.hibernate.tuple.entity."
-"EntityTuplizer</literal> 和 <literal>org.hibernate.tuple.component."
-"ComponentTuplizer</literal> 接口代表。<literal>EntityTuplizer</literal> 负责"
-"管理和实体相关的上述合约，而<literal>ComponentTuplizer</literal> 则负责组件。"
+msgid "There are two high-level types of Tuplizers, represented by the <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> and <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> interfaces. <literal>EntityTuplizer</literal>s are responsible for managing the above mentioned contracts in regards to entities, while <literal>ComponentTuplizer</literal>s do the same for components."
+msgstr "有两种高层类型的 Tuplizer，分别由 <literal>org.hibernate.tuple.entity.EntityTuplizer</literal> 和 <literal>org.hibernate.tuple.component.ComponentTuplizer</literal> 接口代表。<literal>EntityTuplizer</literal> 负责管理和实体相关的上述合约，而<literal>ComponentTuplizer</literal> 则负责组件。"
#. Tag: para
#, no-c-format
-msgid ""
-"Users can also plug in their own tuplizers. Perhaps you require that a "
-"<literal>java.util.Map</literal> implementation other than <literal>java."
-"util.HashMap</literal> be used while in the dynamic-map entity-mode. Or "
-"perhaps you need to define a different proxy generation strategy than the "
-"one used by default. Both would be achieved by defining a custom tuplizer "
-"implementation. Tuplizer definitions are attached to the entity or component "
-"mapping they are meant to manage. Going back to the example of our customer "
-"entity:"
-msgstr ""
-"用户也可以插入其自定义的 tuplizer。或许您需要一种不同于 dynamic-map entity-"
-"mode 中使用的 <literal>java.util.HashMap</literal> 的 <literal>java.util."
-"Map</literal> 实现；或许您需要与默认策略不同的代理生成策略（proxy generation "
-"strategy）。通过自定义 tuplizer 实现，这两个目标您都可以达到。Tuplizer 定义被"
-"附加到它们期望管理的 entity 或者 component 映射中。回到我们的 customer "
-"entity 例子： "
+msgid "Users can also plug in their own tuplizers. Perhaps you require that a <literal>java.util.Map</literal> implementation other than <literal>java.util.HashMap</literal> be used while in the dynamic-map entity-mode. Or perhaps you need to define a different proxy generation strategy than the one used by default. Both would be achieved by defining a custom tuplizer implementation. Tuplizer definitions are attached to the entity or component mapping they are meant to manage. Going back to the example of our customer entity:"
+msgstr "用户也可以插入其自定义的 tuplizer。或许您需要一种不同于 dynamic-map entity-mode 中使用的 <literal>java.util.HashMap</literal> 的 <literal>java.util.Map</literal> 实现；或许您需要与默认策略不同的代理生成策略（proxy generation strategy）。通过自定义 tuplizer 实现，这两个目标您都可以达到。Tuplizer 定义被附加到它们期望管理的 entity 或者 component 映射中。回到我们的 customer entity 例子： "
#. Tag: title
#, no-c-format
@@ -535,59 +267,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <interfacename>org.hibernate.EntityNameResolver</interfacename> "
-"interface is a contract for resolving the entity name of a given entity "
-"instance. The interface defines a single method "
-"<methodname>resolveEntityName</methodname> which is passed the entity "
-"instance and is expected to return the appropriate entity name (null is "
-"allowed and would indicate that the resolver does not know how to resolve "
-"the entity name of the given entity instance). Generally speaking, an "
-"<interfacename>org.hibernate.EntityNameResolver</interfacename> is going to "
-"be most useful in the case of dynamic models. One example might be using "
-"proxied interfaces as your domain model. The hibernate test suite has an "
-"example of this exact style of usage under the <package>org.hibernate.test."
-"dynamicentity.tuplizer2</package>. Here is some of the code from that "
-"package for illustration."
-msgstr ""
-"<interfacename>org.hibernate.EntityNameResolver</interfacename> 接口是一个解"
-"析给定实体实例的实体名称的合约。这个接口定义了一个单一的方法 "
-"<methodname>resolveEntityName</methodname>，它传递实体实例并预期返回合适的实"
-"体名称（null 指明解析器不知道如何解析给定实体实例的实体名称）。一般说来，"
-"<interfacename>org.hibernate.EntityNameResolver</interfacename> 在动态模型里"
-"最为有用。其中的例子是把代理接口用作你的域模型。Hibernate Test Suite 在 "
-"<package>org.hibernate.test.dynamicentity.tuplizer2</package> 下有具有完全相"
-"同风格的例子。下面是该包里的一些代码："
+msgid "The <interfacename>org.hibernate.EntityNameResolver</interfacename> interface is a contract for resolving the entity name of a given entity instance. The interface defines a single method <methodname>resolveEntityName</methodname> which is passed the entity instance and is expected to return the appropriate entity name (null is allowed and would indicate that the resolver does not know how to resolve the entity name of the given entity instance). Generally speaking, an <interfacename>org.hibernate.EntityNameResolver</interfacename> is going to be most useful in the case of dynamic models. One example might be using proxied interfaces as your domain model. The hibernate test suite has an example of this exact style of usage under the <package>org.hibernate.test.dynamicentity.tuplizer2</package>. Here is some of the code from that package for illustration."
+msgstr "<interfacename>org.hibernate.EntityNameResolver</interfacename> 接口是一个解析给定实体实例的实体名称的合约。这个接口定义了一个单一的方法 <methodname>resolveEntityName</methodname>，它传递实体实例并预期返回合适的实体名称（null 指明解析器不知道如何解析给定实体实例的实体名称）。一般说来，<interfacename>org.hibernate.EntityNameResolver</interfacename> 在动态模型里最为有用。其中的例子是把代理接口用作你的域模型。Hibernate Test Suite 在 <package>org.hibernate.test.dynamicentity.tuplizer2</package> 下有具有完全相同风格的例子。下面是该包里的一些代码："
#. Tag: para
#, no-c-format
-msgid ""
-"In order to register an <interfacename>org.hibernate.EntityNameResolver</"
-"interfacename> users must either:"
-msgstr ""
-"为了注册 <interfacename>org.hibernate.EntityNameResolver</interfacename>，用"
-"户必须："
+msgid "In order to register an <interfacename>org.hibernate.EntityNameResolver</interfacename> users must either:"
+msgstr "为了注册 <interfacename>org.hibernate.EntityNameResolver</interfacename>，用户必须："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Implement a custom <xref linkend=\"persistent-classes-tuplizers\" />, "
-"implementing the <methodname>getEntityNameResolvers</methodname> method."
-msgstr ""
-"实现自定义的 <xref linkend=\"persistent-classes-tuplizers\"/> 并实现 "
-"<methodname>getEntityNameResolvers</methodname> 方法。"
+#, no-c-format
+msgid "Implement a custom <xref linkend=\"persistent-classes-tuplizers\" />, implementing the <methodname>getEntityNameResolvers</methodname> method."
+msgstr "实现自定义的 <xref linkend=\"persistent-classes-tuplizers\"/> 并实现 <methodname>getEntityNameResolvers</methodname> 方法。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Register it with the <classname>org.hibernate.impl.SessionFactoryImpl</"
-"classname> (which is the implementation class for <interfacename>org."
-"hibernate.SessionFactory</interfacename>) using the "
-"<methodname>registerEntityNameResolver</methodname> method."
-msgstr ""
-"用 <methodname>registerEntityNameResolver</methodname> 方法注册到 "
-"<classname>org.hibernate.impl.SessionFactoryImpl</classname>（它是 "
-"<interfacename>org.hibernate.SessionFactory</interfacename> 的实现类）。"
+msgid "Register it with the <classname>org.hibernate.impl.SessionFactoryImpl</classname> (which is the implementation class for <interfacename>org.hibernate.SessionFactory</interfacename>) using the <methodname>registerEntityNameResolver</methodname> method."
+msgstr "用 <methodname>registerEntityNameResolver</methodname> 方法注册到 <classname>org.hibernate.impl.SessionFactoryImpl</classname>（它是 <interfacename>org.hibernate.SessionFactory</interfacename> 的实现类）。"
#~ msgid ""
#~ "<![CDATA[package eg;\n"
@@ -747,7 +443,6 @@
#~ " kittens.add(kitten);\n"
#~ " }\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[package eg;\n"
#~ "\n"
@@ -774,7 +469,6 @@
#~ " this.name=name;\n"
#~ " }\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[public class Cat {\n"
#~ "\n"
@@ -823,7 +517,6 @@
#~ " }\n"
#~ "\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[<hibernate-mapping>\n"
#~ "\n"
@@ -892,7 +585,6 @@
#~ " </class>\n"
#~ " \n"
#~ "</hibernate-mapping>]]>"
-
#~ msgid ""
#~ "<![CDATA[Session s = openSession();\n"
#~ "Transaction tx = s.beginTransaction();\n"
@@ -937,7 +629,6 @@
#~ "\n"
#~ "tx.commit();\n"
#~ "s.close();]]>"
-
#~ msgid ""
#~ "<![CDATA[Session dynamicSession = pojoSession.getSession(EntityMode."
#~ "MAP);\n"
@@ -966,7 +657,6 @@
#~ "...\n"
#~ "// Continue on pojoSession\n"
#~ "]]>"
-
#~ msgid ""
#~ "<![CDATA[<hibernate-mapping>\n"
#~ " <class entity-name=\"Customer\">\n"
@@ -1041,7 +731,6 @@
#~ " }\n"
#~ " }\n"
#~ "}]]>"
-
#~ msgid ""
#~ "/**\n"
#~ " * A very trivial JDK Proxy InvocationHandler implementation where we "
@@ -1300,3 +989,4 @@
#~ "\n"
#~ " ...\n"
#~ "}"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/portability.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/portability.po 2009-12-07 10:21:17 UTC (rev 97494)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/portability.po 2009-12-07 11:14:45 UTC (rev 97495)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-12-07 20:00+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -15,27 +15,19 @@
"X-Generator: KBabel 1.11.4\n"
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Database Portability Considerations"
-msgstr "数据库事务声明"
+msgstr "数据库移植性考量"
#. Tag: title
#, no-c-format
msgid "Portability Basics"
-msgstr ""
+msgstr "移植性基础"
#. Tag: para
#, no-c-format
-msgid ""
-"One of the selling points of Hibernate (and really Object/Relational Mapping "
-"as a whole) is the notion of database portability. This could mean an "
-"internal IT user migrating from one database vendor to another, or it could "
-"mean a framework or deployable application consuming Hibernate to "
-"simultaneously target multiple database products by their users. Regardless "
-"of the exact scenario, the basic idea is that you want Hibernate to help you "
-"run against any number of databases without changes to your code, and "
-"ideally without any changes to the mapping metadata."
-msgstr ""
+msgid "One of the selling points of Hibernate (and really Object/Relational Mapping as a whole) is the notion of database portability. This could mean an internal IT user migrating from one database vendor to another, or it could mean a framework or deployable application consuming Hibernate to simultaneously target multiple database products by their users. Regardless of the exact scenario, the basic idea is that you want Hibernate to help you run against any number of databases without changes to your code, and ideally without any changes to the mapping metadata."
+msgstr "Hibernate（实际上是整个 Object/Relational Mapping）的一个卖点是数据库的移植性。这意味着内部的 IT 用户可以改变数据库供应商，或者可部署的应用程序/框架使用 Hibernate 来同时使用多个数据库产品。不考虑具体的应用情景，这里的基本概念是 Hibernate 可帮助你运行多种数据库而无需修改你的代码，理想情况下甚至不用修改映射元数据。"
#. Tag: title
#, no-c-format
@@ -44,183 +36,96 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The first line of portability for Hibernate is the dialect, which is a "
-"specialization of the <classname>org.hibernate.dialect.Dialect</classname> "
-"contract. A dialect encapsulates all the differences in how Hibernate must "
-"communicate with a particular database to accomplish some task like getting "
-"a sequence value or structuring a SELECT query. Hibernate bundles a wide "
-"range of dialects for many of the most popular databases. If you find that "
-"your particular database is not among them, it is not terribly difficult to "
-"write your own."
+msgid "The first line of portability for Hibernate is the dialect, which is a specialization of the <classname>org.hibernate.dialect.Dialect</classname> contract. A dialect encapsulates all the differences in how Hibernate must communicate with a particular database to accomplish some task like getting a sequence value or structuring a SELECT query. Hibernate bundles a wide range of dialects for many of the most popular databases. If you find that your particular database is not among them, it is not terribly difficult to write your own."
msgstr ""
#. Tag: title
#, no-c-format
msgid "Dialect resolution"
-msgstr ""
+msgstr "方言的使用"
#. Tag: para
#, no-c-format
-msgid ""
-"Originally, Hibernate would always require that users specify which dialect "
-"to use. In the case of users looking to simultaneously target multiple "
-"databases with their build that was problematic. Generally this required "
-"their users to configure the Hibernate dialect or defining their own method "
-"of setting that value."
-msgstr ""
+msgid "Originally, Hibernate would always require that users specify which dialect to use. In the case of users looking to simultaneously target multiple databases with their build that was problematic. Generally this required their users to configure the Hibernate dialect or defining their own method of setting that value."
+msgstr "最开始，Hibernate 总是要求用户指定所使用的方言（dialect）。在用户希望同时使用多个数据库时就会出现问题。通常这要求用户配置 Hibernate 方言或者定义自己设置这个值的方法。"
#. Tag: para
#, no-c-format
-msgid ""
-"Starting with version 3.2, Hibernate introduced the notion of automatically "
-"detecting the dialect to use based on the <interfacename>java.sql."
-"DatabaseMetaData</interfacename> obtained from a <interfacename>java.sql."
-"Connection</interfacename> to that database. This was much better, expect "
-"that this resolution was limited to databases Hibernate know about ahead of "
-"time and was in no way configurable or overrideable."
+msgid "Starting with version 3.2, Hibernate introduced the notion of automatically detecting the dialect to use based on the <interfacename>java.sql.DatabaseMetaData</interfacename> obtained from a <interfacename>java.sql.Connection</interfacename> to that database. This was much better, expect that this resolution was limited to databases Hibernate know about ahead of time and was in no way configurable or overrideable."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Starting with version 3.3, Hibernate has a fare more powerful way to "
-"automatically determine which dialect to should be used by relying on a "
-"series of delegates which implement the <interfacename>org.hibernate.dialect."
-"resolver.DialectResolver</interfacename> which defines only a single method:"
-"<programlisting>public Dialect resolveDialect(DatabaseMetaData metaData) "
-"throws JDBCConnectionException</programlisting>. The basic contract here is "
-"that if the resolver 'understands' the given database metadata then it "
-"returns the corresponding Dialect; if not it returns null and the process "
-"continues to the next resolver. The signature also identifies "
-"<exceptionname>org.hibernate.exception.JDBCConnectionException</"
-"exceptionname> as possibly being thrown. A JDBCConnectionException here is "
-"interpreted to imply a \"non transient\" (aka non-recoverable) connection "
-"problem and is used to indicate an immediate stop to resolution attempts. "
-"All other exceptions result in a warning and continuing on to the next "
-"resolver."
+msgid "Starting with version 3.3, Hibernate has a fare more powerful way to automatically determine which dialect to should be used by relying on a series of delegates which implement the <interfacename>org.hibernate.dialect.resolver.DialectResolver</interfacename> which defines only a single method:<programlisting>public Dialect resolveDialect(DatabaseMetaData metaData) throws JDBCConnectionException</programlisting>. The basic contract here is that if the resolver 'understands' the given database metadata then it returns the corresponding Dialect; if not it returns null and the process continues to the next resolver. The signature also identifies <exceptionname>org.hibernate.exception.JDBCConnectionException</exceptionname> as possibly being thrown. A JDBCConnectionException here is interpreted to imply a \"non transient\" (aka non-recoverable) connection problem and is used to indicate an immediate stop to resolution attempts. All other exceptions result in a warning and!
continuing on to the next resolver."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"The cool part about these resolvers is that users can also register their "
-"own custom resolvers which will be processed ahead of the built-in Hibernate "
-"ones. This might be useful in a number of different situations: it allows "
-"easy integration for auto-detection of dialects beyond those shipped with "
-"HIbernate itself; it allows you to specify to use a custom dialect when a "
-"particular database is recognized; etc. To register one or more resolvers, "
-"simply specify them (seperated by commas, tabs or spaces) using the "
-"'hibernate.dialect_resolvers' configuration setting (see the "
-"<constant>DIALECT_RESOLVERS</constant> constant on <classname>org.hibernate."
-"cfg.Environment</classname>)."
+msgid "The cool part about these resolvers is that users can also register their own custom resolvers which will be processed ahead of the built-in Hibernate ones. This might be useful in a number of different situations: it allows easy integration for auto-detection of dialects beyond those shipped with HIbernate itself; it allows you to specify to use a custom dialect when a particular database is recognized; etc. To register one or more resolvers, simply specify them (seperated by commas, tabs or spaces) using the 'hibernate.dialect_resolvers' configuration setting (see the <constant>DIALECT_RESOLVERS</constant> constant on <classname>org.hibernate.cfg.Environment</classname>)."
msgstr ""
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Identifier generation"
-msgstr "标志符的 getter 方法。"
+msgstr "标识符的生成"
#. Tag: para
#, no-c-format
-msgid ""
-"When considering portability between databases, another important decision "
-"is selecting the identifier generation stratagy you want to use. Originally "
-"Hibernate provided the <emphasis>native</emphasis> generator for this "
-"purpose, which was intended to select between a <emphasis>sequence</"
-"emphasis>, <emphasis>identity</emphasis>, or <emphasis>table</emphasis> "
-"strategy depending on the capability of the underlying database. However, an "
-"insidious implication of this approach comes about when targtetting some "
-"databases which support <emphasis>identity</emphasis> generation and some "
-"which do not. <emphasis>identity</emphasis> generation relies on the SQL "
-"definition of an IDENTITY (or auto-increment) column to manage the "
-"identifier value; it is what is known as a post-insert generation strategy "
-"becauase the insert must actually happen before we can know the identifier "
-"value. Because Hibernate relies on this identifier value to uniquely "
-"reference entities within a persistence context it must then issue the "
-"insert immediately when the users requests the entitiy be associated with "
-"the session (like via save() e.g.) regardless of current transactional "
-"semantics. The underlying issue is that the semanctics of the application "
-"itself changes in these cases."
+msgid "When considering portability between databases, another important decision is selecting the identifier generation stratagy you want to use. Originally Hibernate provided the <emphasis>native</emphasis> generator for this purpose, which was intended to select between a <emphasis>sequence</emphasis>, <emphasis>identity</emphasis>, or <emphasis>table</emphasis> strategy depending on the capability of the underlying database. However, an insidious implication of this approach comes about when targtetting some databases which support <emphasis>identity</emphasis> generation and some which do not. <emphasis>identity</emphasis> generation relies on the SQL definition of an IDENTITY (or auto-increment) column to manage the identifier value; it is what is known as a post-insert generation strategy becauase the insert must actually happen before we can know the identifier value. Because Hibernate relies on this identifier value to uniquely reference entities within a persisten!
ce context it must then issue the insert immediately when the users requests the entitiy be associated with the session (like via save() e.g.) regardless of current transactional semantics. The underlying issue is that the semanctics of the application itself changes in these cases."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate has been improved so that the insert is delayed in cases where "
-"that is feasible."
-msgstr ""
+msgid "Hibernate has been improved so that the insert is delayed in cases where that is feasible."
+msgstr "Hibernate 已经进行了改进，所以在可行时这种插入会被延迟。"
#. Tag: para
#, no-c-format
-msgid ""
-"Starting with version 3.2.3, Hibernate comes with a set of <ulink url="
-"\"http://in.relation.to/2082.lace\">enhanced</ulink> identifier generators "
-"targetting portability in a much different way."
-msgstr ""
+msgid "Starting with version 3.2.3, Hibernate comes with a set of <ulink url=\"http://in.relation.to/2082.lace\">enhanced</ulink> identifier generators targetting portability in a much different way."
+msgstr "从 3.2.3 版本开始，Hibernate 带有一套 <ulink url=\"http://in.relation.to/2082.lace\">enhanced</ulink> 标识符生成器，它以很不同的方式实现移植性。"
#. Tag: para
#, no-c-format
-msgid ""
-"There are specifically 2 bundled <emphasis>enhanced</emphasis>generators:"
-msgstr ""
+msgid "There are specifically 2 bundled <emphasis>enhanced</emphasis>generators:"
+msgstr "特别是两个捆绑的 <emphasis>enhanced</emphasis> 生成器："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<classname>org.hibernate.id.enhanced.SequenceStyleGenerator</classname>"
-msgstr "org.hibernate.cache.TreeCacheProvider"
+msgstr "<classname>org.hibernate.id.enhanced.SequenceStyleGenerator</classname>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<classname>org.hibernate.id.enhanced.TableGenerator</classname>"
-msgstr "org.hibernate.cache.TreeCacheProvider"
+msgstr "<classname>org.hibernate.id.enhanced.TableGenerator</classname>"
#. Tag: para
#, no-c-format
-msgid ""
-"The idea behind these generators is to port the actual semantics of the "
-"identifer value generation to the different databases. For example, the "
-"<classname>org.hibernate.id.enhanced.SequenceStyleGenerator</classname> "
-"mimics the behavior of a sequence on databases which do not support "
-"sequences by using a table."
-msgstr ""
+msgid "The idea behind these generators is to port the actual semantics of the identifer value generation to the different databases. For example, the <classname>org.hibernate.id.enhanced.SequenceStyleGenerator</classname> mimics the behavior of a sequence on databases which do not support sequences by using a table."
+msgstr "这些生成器背后的概念是把标识符值生成的实际情景移植到不同的数据库里。例如，<classname>org.hibernate.id.enhanced.SequenceStyleGenerator</classname> 通过使用表来模拟不支持序列（sequences）的数据库上的序列行为。"
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Database functions"
-msgstr "聚集函数"
+msgstr "数据库函数"
#. Tag: para
#, no-c-format
-msgid ""
-"This is a new area in Hibernate and as such it is not as mature as the "
-"overall Hibernate experience."
+msgid "This is a new area in Hibernate and as such it is not as mature as the overall Hibernate experience."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"SQL functions can be referenced in many ways by users. However, not all "
-"databases support the same set of functions. Hibernate, provides a means of "
-"mapping a <emphasis>logical</emphasis> function name to a a delegate which "
-"knows how to render that particular function, perhaps even using a totally "
-"different physical function call."
+msgid "SQL functions can be referenced in many ways by users. However, not all databases support the same set of functions. Hibernate, provides a means of mapping a <emphasis>logical</emphasis> function name to a a delegate which knows how to render that particular function, perhaps even using a totally different physical function call."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"Technically this function registration is handled through the <classname>org."
-"hibernate.dialect.function.SQLFunctionRegistry</classname> class which is "
-"intended to allow users to provide custom function definitions without "
-"having to provide a custom dialect. This specific behavior is not fully "
-"completed as of yet."
+msgid "Technically this function registration is handled through the <classname>org.hibernate.dialect.function.SQLFunctionRegistry</classname> class which is intended to allow users to provide custom function definitions without having to provide a custom dialect. This specific behavior is not fully completed as of yet."
msgstr ""
#. Tag: para
#, no-c-format
-msgid ""
-"It is sort of implemented such that users can programatically register "
-"functions with the <classname>org.hibernate.cfg.Configuration</classname> "
-"and those functions will be recognized for HQL."
+msgid "It is sort of implemented such that users can programatically register functions with the <classname>org.hibernate.cfg.Configuration</classname> and those functions will be recognized for HQL."
msgstr ""
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_criteria.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_criteria.po 2009-12-07 10:21:17 UTC (rev 97494)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_criteria.po 2009-12-07 11:14:45 UTC (rev 97495)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-12-07 20:31+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -25,19 +25,14 @@
msgstr "具有一个直观的、可扩展的条件查询 API 是 Hibernate 的特色。"
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Creating a <literal>Criteria</literal> instance"
-msgstr "创建一个 Criteria 实例"
+msgstr "创建一个 <literal>Criteria</literal> 实例"
#. Tag: para
#, no-c-format
-msgid ""
-"The interface <literal>org.hibernate.Criteria</literal> represents a query "
-"against a particular persistent class. The <literal>Session</literal> is a "
-"factory for <literal>Criteria</literal> instances."
-msgstr ""
-"<literal>org.hibernate.Criteria</literal >接口表示特定持久类的一个查询。"
-"<literal>Session</literal> 是 <literal>Criteria</literal> 实例的工厂。"
+msgid "The interface <literal>org.hibernate.Criteria</literal> represents a query against a particular persistent class. The <literal>Session</literal> is a factory for <literal>Criteria</literal> instances."
+msgstr "<literal>org.hibernate.Criteria</literal >接口表示特定持久类的一个查询。<literal>Session</literal> 是 <literal>Criteria</literal> 实例的工厂。"
#. Tag: title
#, no-c-format
@@ -46,47 +41,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"An individual query criterion is an instance of the interface <literal>org."
-"hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate."
-"criterion.Restrictions</literal> defines factory methods for obtaining "
-"certain built-in <literal>Criterion</literal> types."
-msgstr ""
-"一个单独的查询条件是 <literal>org.hibernate.criterion.Criterion</literal> 接"
-"口的一个实例。<literal>org.hibernate.criterion.Restrictions</literal> 类定义"
-"了获得某些内置 <literal>Criterion</literal> 类型的工厂方法。"
+msgid "An individual query criterion is an instance of the interface <literal>org.hibernate.criterion.Criterion</literal>. The class <literal>org.hibernate.criterion.Restrictions</literal> defines factory methods for obtaining certain built-in <literal>Criterion</literal> types."
+msgstr "一个单独的查询条件是 <literal>org.hibernate.criterion.Criterion</literal> 接口的一个实例。<literal>org.hibernate.criterion.Restrictions</literal> 类定义了获得某些内置 <literal>Criterion</literal> 类型的工厂方法。"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Restrictions can be grouped logically."
-msgstr "约束可以按逻辑分组。"
+msgstr "约束可以按逻辑分组。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"There are a range of built-in criterion types (<literal>Restrictions</"
-"literal> subclasses). One of the most useful allows you to specify SQL "
-"directly."
-msgstr ""
-"Hibernate 提供了相当多的内置 criterion 类型（<literal>Restrictions</literal> "
-"子类），但是尤其有用的是可以允许你直接使用 SQL。"
+#, no-c-format
+msgid "There are a range of built-in criterion types (<literal>Restrictions</literal> subclasses). One of the most useful allows you to specify SQL directly."
+msgstr "Hibernate 提供了相当多的内置 criterion 类型（<literal>Restrictions</literal> 子类），但是尤其有用的是可以允许你直接使用 SQL。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>{alias}</literal> placeholder with be replaced by the row alias "
-"of the queried entity."
+msgid "The <literal>{alias}</literal> placeholder with be replaced by the row alias of the queried entity."
msgstr "<literal>{alias}</literal> 占位符应当被替换为被查询实体的列别名。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can also obtain a criterion from a <literal>Property</literal> instance. "
-"You can create a <literal>Property</literal> by calling <literal>Property."
-"forName()</literal>:"
-msgstr ""
-"<literal>Property</literal> 实例是获得一个条件的另外一种途径。你可以通过调用 "
-"<literal>Property.forName()</literal> 创建一个 <literal>Property</literal>。"
+#, no-c-format
+msgid "You can also obtain a criterion from a <literal>Property</literal> instance. You can create a <literal>Property</literal> by calling <literal>Property.forName()</literal>:"
+msgstr "<literal>Property</literal> 实例是获得一个条件的另外一种途径。你可以通过调用 <literal>Property.forName()</literal> 创建一个 <literal>Property</literal>："
#. Tag: title
#, no-c-format
@@ -94,13 +70,9 @@
msgstr "结果集排序"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can order the results using <literal>org.hibernate.criterion.Order</"
-"literal>."
-msgstr ""
-"你可以使用 <literal>org.hibernate.criterion.Order</literal> 来为查询结果排"
-"序。"
+#, no-c-format
+msgid "You can order the results using <literal>org.hibernate.criterion.Order</literal>."
+msgstr "你可以使用 <literal>org.hibernate.criterion.Order</literal> 来为查询结果排序。 "
#. Tag: title
#, no-c-format
@@ -109,48 +81,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"By navigating associations using <literal>createCriteria()</literal> you can "
-"specify constraints upon related entities:"
-msgstr ""
+msgid "By navigating associations using <literal>createCriteria()</literal> you can specify constraints upon related entities:"
+msgstr "通过使用 <literal>createCriteria()</literal> 对关联进行导航，你可以指定相关实体的约束。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The second <literal>createCriteria()</literal> returns a new instance of "
-"<literal>Criteria</literal> that refers to the elements of the "
-"<literal>kittens</literal> collection."
-msgstr ""
-"注意第二个 <literal>createCriteria()</literal> 返回一个新的 "
-"<literal>Criteria</literal> 实例，该实例引用 <literal>kittens</literal> 集合"
-"中的元素。"
+#, no-c-format
+msgid "The second <literal>createCriteria()</literal> returns a new instance of <literal>Criteria</literal> that refers to the elements of the <literal>kittens</literal> collection."
+msgstr "注意第二个 <literal>createCriteria()</literal> 返回一个新的 <literal>Criteria</literal> 实例，该实例引用 <literal>kittens</literal> 集合中的元素。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"There is also an alternate form that is useful in certain circumstances:"
-msgstr "接下来，替换形态在某些情况下也是很有用的。"
+#, no-c-format
+msgid "There is also an alternate form that is useful in certain circumstances:"
+msgstr "接下来，替换形态在某些情况下也是很有用的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"(<literal>createAlias()</literal> does not create a new instance of "
-"<literal>Criteria</literal>.)"
-msgstr ""
-"（<literal>createAlias()</literal> 并不创建一个新的 <literal>Criteria</"
-"literal> 实例。）"
+msgid "(<literal>createAlias()</literal> does not create a new instance of <literal>Criteria</literal>.)"
+msgstr "（<literal>createAlias()</literal> 并不创建一个新的 <literal>Criteria</literal> 实例。）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The kittens collections held by the <literal>Cat</literal> instances "
-"returned by the previous two queries are <emphasis>not</emphasis> pre-"
-"filtered by the criteria. If you want to retrieve just the kittens that "
-"match the criteria, you must use a <literal>ResultTransformer</literal>."
-msgstr ""
-"<literal>Cat</literal> 实例所保存的之前两次查询所返回的 kittens 集合是 "
-"<emphasis>没有</emphasis>被条件预过滤的。如果你希望只获得符合条件的 kittens，"
-"你必须使用 <literal>ResultTransformer</literal>。"
+#, no-c-format
+msgid "The kittens collections held by the <literal>Cat</literal> instances returned by the previous two queries are <emphasis>not</emphasis> pre-filtered by the criteria. If you want to retrieve just the kittens that match the criteria, you must use a <literal>ResultTransformer</literal>."
+msgstr "<literal>Cat</literal> 实例所保存的之前两次查询所返回的 kittens 集合是 <emphasis>没有</emphasis>被条件预过滤的。如果你希望只获得符合条件的 kittens，你必须使用 <literal>ResultTransformer</literal>。 "
#. Tag: title
#, no-c-format
@@ -158,23 +110,14 @@
msgstr "动态关联抓取"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can specify association fetching semantics at runtime using "
-"<literal>setFetchMode()</literal>."
-msgstr ""
-"你可以使用 <literal>setFetchMode()</literal> 在运行时定义动态关联抓取的语义。"
+#, no-c-format
+msgid "You can specify association fetching semantics at runtime using <literal>setFetchMode()</literal>."
+msgstr "你可以使用 <literal>setFetchMode()</literal> 在运行时定义动态关联抓取的语义。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This query will fetch both <literal>mate</literal> and <literal>kittens</"
-"literal> by outer join. See <xref linkend=\"performance-fetching\" /> for "
-"more information."
-msgstr ""
-"这个查询可以通过外连接抓取 <literal>mate</literal> 和 <literal>kittens</"
-"literal>。查看 <xref linkend=\"Improving_performance-Fetching_strategies\"/> "
-"可以获得更多信息。"
+#, no-c-format
+msgid "This query will fetch both <literal>mate</literal> and <literal>kittens</literal> by outer join. See <xref linkend=\"performance-fetching\" /> for more information."
+msgstr "这个查询可以通过外连接抓取 <literal>mate</literal> 和 <literal>kittens</literal>。查看 <xref linkend=\"performance-fetching\" /> 可以获得更多信息。"
#. Tag: title
#, no-c-format
@@ -183,18 +126,12 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The class <literal>org.hibernate.criterion.Example</literal> allows you to "
-"construct a query criterion from a given instance."
-msgstr ""
-"<literal>org.hibernate.criterion.Example</literal> 类允许你通过一个给定实例构"
-"建一个条件查询。"
+msgid "The class <literal>org.hibernate.criterion.Example</literal> allows you to construct a query criterion from a given instance."
+msgstr "<literal>org.hibernate.criterion.Example</literal> 类允许你通过一个给定实例构建一个条件查询。"
#. Tag: para
#, no-c-format
-msgid ""
-"Version properties, identifiers and associations are ignored. By default, "
-"null valued properties are excluded."
+msgid "Version properties, identifiers and associations are ignored. By default, null valued properties are excluded."
msgstr "版本属性、标识符和关联被忽略。默认情况下值为 null 的属性将被排除。"
#. Tag: para
@@ -213,54 +150,28 @@
msgstr "投影（Projections）、聚合（aggregation）和分组（grouping）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The class <literal>org.hibernate.criterion.Projections</literal> is a "
-"factory for <literal>Projection</literal> instances. You can apply a "
-"projection to a query by calling <literal>setProjection()</literal>."
-msgstr ""
-"<literal>org.hibernate.criterion.Projections</literal> 是 "
-"<literal>Projection</literal> 的实例工厂。我们通过调用 <literal>setProjection"
-"()</literal> 应用投影到一个查询。"
+#, no-c-format
+msgid "The class <literal>org.hibernate.criterion.Projections</literal> is a factory for <literal>Projection</literal> instances. You can apply a projection to a query by calling <literal>setProjection()</literal>."
+msgstr "<literal>org.hibernate.criterion.Projections</literal> 是 <literal>Projection</literal> 的实例工厂。我们通过调用 <literal>setProjection()</literal> 应用投影到一个查询。 "
#. Tag: para
#, no-c-format
-msgid ""
-"There is no explicit \"group by\" necessary in a criteria query. Certain "
-"projection types are defined to be <emphasis>grouping projections</"
-"emphasis>, which also appear in the SQL <literal>group by</literal> clause."
-msgstr ""
-"在一个条件查询中没有必要显式的使用 \"group by\" 。某些投影类型就是被定义为"
-"<emphasis>分组投影</emphasis>，他们也出现在 SQL 的 <literal>group by</"
-"literal> 子句中。"
+msgid "There is no explicit \"group by\" necessary in a criteria query. Certain projection types are defined to be <emphasis>grouping projections</emphasis>, which also appear in the SQL <literal>group by</literal> clause."
+msgstr "在一个条件查询中没有必要显式的使用 \"group by\" 。某些投影类型就是被定义为<emphasis>分组投影</emphasis>，他们也出现在 SQL 的 <literal>group by</literal> 子句中。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"An alias can be assigned to a projection so that the projected value can be "
-"referred to in restrictions or orderings. Here are two different ways to do "
-"this:"
-msgstr ""
-"你可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面"
-"是两种不同的实现方式："
+#, no-c-format
+msgid "An alias can be assigned to a projection so that the projected value can be referred to in restrictions or orderings. Here are two different ways to do this:"
+msgstr "你可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的实现方式： "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>alias()</literal> and <literal>as()</literal> methods simply "
-"wrap a projection instance in another, aliased, instance of "
-"<literal>Projection</literal>. As a shortcut, you can assign an alias when "
-"you add the projection to a projection list:"
-msgstr ""
-"<literal>alias()</literal> 和 <literal>as()</literal> 方法简便的将一个投影实"
-"例包装到另外一个 别名的 <literal>Projection</literal> 实例中。简而言之，当你"
-"添加一个投影到一个投影列表中时你可以为它指定一个别名："
+msgid "The <literal>alias()</literal> and <literal>as()</literal> methods simply wrap a projection instance in another, aliased, instance of <literal>Projection</literal>. As a shortcut, you can assign an alias when you add the projection to a projection list:"
+msgstr "<literal>alias()</literal> 和 <literal>as()</literal> 方法简便的将一个投影实例包装到另外一个 别名的 <literal>Projection</literal> 实例中。简而言之，当你添加一个投影到一个投影列表中时你可以为它指定一个别名："
#. Tag: para
#, no-c-format
-msgid ""
-"You can also use <literal>Property.forName()</literal> to express "
-"projections:"
+msgid "You can also use <literal>Property.forName()</literal> to express projections:"
msgstr "你也可以使用 <literal>Property.forName()</literal> 来表示投影："
#. Tag: title
@@ -269,30 +180,19 @@
msgstr "离线（detached）查询和子查询"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>DetachedCriteria</literal> class allows you to create a query "
-"outside the scope of a session and then execute it using an arbitrary "
-"<literal>Session</literal>."
-msgstr ""
-"<literal>DetachedCriteria</literal> 类使你在一个 session 范围之外创建一个查"
-"询，并且可以使用任意的 <literal>Session</literal> 来执行它。"
+#, no-c-format
+msgid "The <literal>DetachedCriteria</literal> class allows you to create a query outside the scope of a session and then execute it using an arbitrary <literal>Session</literal>."
+msgstr "<literal>DetachedCriteria</literal> 类使你在一个 session 范围之外创建一个查询，并且可以使用任意的 <literal>Session</literal> 来执行它。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>DetachedCriteria</literal> can also be used to express a "
-"subquery. Criterion instances involving subqueries can be obtained via "
-"<literal>Subqueries</literal> or <literal>Property</literal>."
-msgstr ""
-"<literal>DetachedCriteria</literal> 也可以用以表示子查询。条件实例包含子查询"
-"可以通过 <literal>Subqueries</literal> 或者 <literal>Property</literal> 获"
-"得。"
+#, no-c-format
+msgid "A <literal>DetachedCriteria</literal> can also be used to express a subquery. Criterion instances involving subqueries can be obtained via <literal>Subqueries</literal> or <literal>Property</literal>."
+msgstr "<literal>DetachedCriteria</literal> 也可以用以表示子查询。条件实例包含子查询可以通过 <literal>Subqueries</literal> 或者 <literal>Property</literal> 获得。 "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Correlated subqueries are also possible:"
-msgstr "甚至相互关联的子查询也是有可能的："
+msgstr "甚至相互关联的子查询也是有可能的： "
#. Tag: title
#, no-c-format
@@ -300,46 +200,24 @@
msgstr "根据自然标识查询（Queries by natural identifier）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For most queries, including criteria queries, the query cache is not "
-"efficient because query cache invalidation occurs too frequently. However, "
-"there is a special kind of query where you can optimize the cache "
-"invalidation algorithm: lookups by a constant natural key. In some "
-"applications, this kind of query occurs frequently. The criteria API "
-"provides special provision for this use case."
-msgstr ""
-"对大多数查询，包括条件查询而言，因为查询缓存的失效（invalidation）发生得太频"
-"繁，查询缓存不是非常高效。然而，有一种特别的查询，可以通过不变的自然键优化缓"
-"存的失效算法。在某些应用中，这种类型的查询比较常见。条件查询 API 对这种用例提"
-"供了特别规约。"
+#, no-c-format
+msgid "For most queries, including criteria queries, the query cache is not efficient because query cache invalidation occurs too frequently. However, there is a special kind of query where you can optimize the cache invalidation algorithm: lookups by a constant natural key. In some applications, this kind of query occurs frequently. The criteria API provides special provision for this use case."
+msgstr "对大多数查询，包括条件查询而言，因为查询缓存的失效（invalidation）发生得太频繁，查询缓存不是非常高效。然而，有一种特别的查询，可以通过不变的自然键优化缓存的失效算法。在某些应用中，这种类型的查询比较常见。条件查询 API 对这种用例提供了特别规约。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"First, map the natural key of your entity using <literal><natural-id></"
-"literal> and enable use of the second-level cache."
-msgstr ""
-"首先，你应该对你的 entity 使用 <literal><natural-id></literal> 来映射自"
-"然键，然后打开第二级缓存。"
+#, no-c-format
+msgid "First, map the natural key of your entity using <literal><natural-id></literal> and enable use of the second-level cache."
+msgstr "首先，你应该对你的 entity 使用 <literal><natural-id></literal> 来映射自然键，然后打开第二级缓存。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This functionality is not intended for use with entities with "
-"<emphasis>mutable</emphasis> natural keys."
-msgstr ""
-"注意,此功能对具有<emphasis>mutable</emphasis>自然键的 entity 并不适用。"
+#, no-c-format
+msgid "This functionality is not intended for use with entities with <emphasis>mutable</emphasis> natural keys."
+msgstr "注意,此功能对具有<emphasis>mutable</emphasis>自然键的 entity 并不适用。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Once you have enabled the Hibernate query cache, the <literal>Restrictions."
-"naturalId()</literal> allows you to make use of the more efficient cache "
-"algorithm."
-msgstr ""
-"现在，我们可以用 <literal>Restrictions.naturalId()</literal> 来使用更加高效的"
-"缓存算法。"
+#, no-c-format
+msgid "Once you have enabled the Hibernate query cache, the <literal>Restrictions.naturalId()</literal> allows you to make use of the more efficient cache algorithm."
+msgstr "现在，我们可以用 <literal>Restrictions.naturalId()</literal> 来使用更加高效的缓存算法。 "
#, fuzzy
#~ msgid ""
@@ -847,3 +725,4 @@
#~ " .set(\"org\", \"hb\") \n"
#~ " ).setCacheable(true)\n"
#~ " .uniqueResult();"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_hql.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_hql.po 2009-12-07 10:21:17 UTC (rev 97494)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_hql.po 2009-12-07 11:14:45 UTC (rev 97495)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-12-07 21:13+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -20,15 +20,9 @@
msgstr "HQL: Hibernate 查询语言"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate uses a powerful query language (HQL) that is similar in appearance "
-"to SQL. Compared with SQL, however, HQL is fully object-oriented and "
-"understands notions like inheritance, polymorphism and association."
-msgstr ""
-"Hibernate 配备了一种非常强大的查询语言，这种语言看上去很像 SQL。但是不要被语"
-"法结构上的相似所迷惑，HQL 是非常有意识的被设计为完全面向对象的查询，它可以理"
-"解如继承、多态和关联之类的概念。"
+#, no-c-format
+msgid "Hibernate uses a powerful query language (HQL) that is similar in appearance to SQL. Compared with SQL, however, HQL is fully object-oriented and understands notions like inheritance, polymorphism and association."
+msgstr "Hibernate 配备了一种非常强大的查询语言，这种语言看上去很像 SQL。但是不要被语法结构上的相似所迷惑，HQL 是非常有意识的被设计为完全面向对象的查询，它可以理解如继承、多态和关联之类的概念。 "
#. Tag: title
#, no-c-format
@@ -36,30 +30,14 @@
msgstr "大小写敏感性问题"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"With the exception of names of Java classes and properties, queries are case-"
-"insensitive. So <literal>SeLeCT</literal> is the same as <literal>sELEct</"
-"literal> is the same as <literal>SELECT</literal>, but <literal>org."
-"hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal>, "
-"and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
-msgstr ""
-"除了 Java 类与属性的名称外，查询语句对大小写并不敏感。 所以 <literal>SeLeCT</"
-"literal> 与 <literal>sELEct</literal> 以及 <literal>SELECT</literal> 是相同"
-"的，但是 <literal>org.hibernate.eg.FOO</literal> 并不等价于 <literal>org."
-"hibernate.eg.Foo</literal> 并且 <literal>foo.barSet</literal> 也不等价于 "
-"<literal>foo.BARSET</literal>。"
+#, no-c-format
+msgid "With the exception of names of Java classes and properties, queries are case-insensitive. So <literal>SeLeCT</literal> is the same as <literal>sELEct</literal> is the same as <literal>SELECT</literal>, but <literal>org.hibernate.eg.FOO</literal> is not <literal>org.hibernate.eg.Foo</literal>, and <literal>foo.barSet</literal> is not <literal>foo.BARSET</literal>."
+msgstr "除了 Java 类与属性的名称外，查询语句对大小写并不敏感。 所以 <literal>SeLeCT</literal> 与 <literal>sELEct</literal> 以及 <literal>SELECT</literal> 是相同的，但是 <literal>org.hibernate.eg.FOO</literal> 并不等价于 <literal>org.hibernate.eg.Foo</literal> 并且 <literal>foo.barSet</literal> 也不等价于 <literal>foo.BARSET</literal>。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This manual uses lowercase HQL keywords. Some users find queries with "
-"uppercase keywords more readable, but this convention is unsuitable for "
-"queries embedded in Java code."
-msgstr ""
-"本手册中的 HQL 关键字将使用小写字母。很多用户发现使用完全大写的关键字会使查询"
-"语句 的可读性更强，但我们发现，当把查询语句嵌入到 Java 语句中的时候使用大写关"
-"键字比较难看。"
+#, no-c-format
+msgid "This manual uses lowercase HQL keywords. Some users find queries with uppercase keywords more readable, but this convention is unsuitable for queries embedded in Java code."
+msgstr "本手册中的 HQL 关键字将使用小写字母。很多用户发现使用完全大写的关键字会使查询语句的可读性更强，但我们发现，当把查询语句嵌入到 Java 语句中的时候使用大写关键字比较难看。"
#. Tag: title
#, no-c-format
@@ -72,51 +50,29 @@
msgstr "Hibernate 中最简单的查询语句的形式如下："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This returns all instances of the class <literal>eg.Cat</literal>. You do "
-"not usually need to qualify the class name, since <literal>auto-import</"
-"literal> is the default. For example:"
-msgstr ""
-"该子句简单的返回 <literal>eg.Cat</literal> 类的所有实例。通常我们不需要使用类"
-"的全限定名，因为 <literal>auto-import</literal>（自动引入）是缺省的情况。所"
-"以我们几乎只使用如下的简单写法："
+#, no-c-format
+msgid "This returns all instances of the class <literal>eg.Cat</literal>. You do not usually need to qualify the class name, since <literal>auto-import</literal> is the default. For example:"
+msgstr "该子句简单的返回 <literal>eg.Cat</literal> 类的所有实例。通常我们不需要使用类的全限定名，因为 <literal>auto-import</literal>（自动引入）是缺省的情况。所以我们几乎只使用如下的简单写法： "
#. Tag: para
#, no-c-format
-msgid ""
-"In order to refer to the <literal>Cat</literal> in other parts of the query, "
-"you will need to assign an <emphasis>alias</emphasis>. For example:"
-msgstr ""
+msgid "In order to refer to the <literal>Cat</literal> in other parts of the query, you will need to assign an <emphasis>alias</emphasis>. For example:"
+msgstr "为了在这个查询的其他部分里引用 <literal>Cat</literal>，你将需要分配一个<emphasis>别名</emphasis>。例如："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This query assigns the alias <literal>cat</literal> to <literal>Cat</"
-"literal> instances, so you can use that alias later in the query. The "
-"<literal>as</literal> keyword is optional. You could also write:"
-msgstr ""
-"这个语句把别名 <literal>cat</literal> 指定给类<literal>Cat</literal> 的实例，"
-"这样我们就可以在随后的查询中使用此别名了。关键字 <literal>as</literal> 是可选"
-"的，我们也可以这样写："
+#, no-c-format
+msgid "This query assigns the alias <literal>cat</literal> to <literal>Cat</literal> instances, so you can use that alias later in the query. The <literal>as</literal> keyword is optional. You could also write:"
+msgstr "这个语句把别名 <literal>cat</literal> 指定给类<literal>Cat</literal> 的实例，这样我们就可以在随后的查询中使用此别名了。关键字 <literal>as</literal> 是可选的，我们也可以这样写： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Multiple classes can appear, resulting in a cartesian product or \"cross\" "
-"join."
-msgstr ""
-"子句中可以同时出现多个类，其查询结果是产生一个笛卡儿积或产生跨表的连接。"
+#, no-c-format
+msgid "Multiple classes can appear, resulting in a cartesian product or \"cross\" join."
+msgstr "子句中可以同时出现多个类，其查询结果是产生一个笛卡儿积或产生跨表的连接。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is good practice to name query aliases using an initial lowercase as this "
-"is consistent with Java naming standards for local variables (e.g. "
-"<literal>domesticCat</literal>)."
-msgstr ""
-"查询语句中别名的开头部分小写被认为是实践中的好习惯，这样做与 Java 变量的命名"
-"标准保持了一致（比如，<literal>domesticCat</literal>）。"
+#, no-c-format
+msgid "It is good practice to name query aliases using an initial lowercase as this is consistent with Java naming standards for local variables (e.g. <literal>domesticCat</literal>)."
+msgstr "查询语句中别名的开头部分小写被认为是实践中的好习惯，这样做与 Java 变量的命名标准保持了一致（比如，<literal>domesticCat</literal>）。 "
#. Tag: title
#, no-c-format
@@ -124,33 +80,29 @@
msgstr "关联（Association）与连接（Join）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can also assign aliases to associated entities or to elements of a "
-"collection of values using a <literal>join</literal>. For example:"
-msgstr ""
-"我们也可以为相关联的实体甚至是对一个集合中的全部元素指定一个别名，这时要使用"
-"关键字 <literal>join</literal>。"
+#, no-c-format
+msgid "You can also assign aliases to associated entities or to elements of a collection of values using a <literal>join</literal>. For example:"
+msgstr "我们也可以为相关联的实体甚至是对一个集合中的全部元素指定一个别名，这时要使用关键字 <literal>join</literal>。 "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The supported join types are borrowed from ANSI SQL:"
-msgstr "受支持的连接类型是从 ANSI SQL 中借鉴来的。"
+msgstr "受支持的连接类型是从 ANSI SQL 中借鉴来的："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>inner join</literal>"
-msgstr "或存放在一个 <literal>List</literal> 对象中，"
+msgstr "<literal>inner join</literal>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>left outer join</literal>"
-msgstr "<literal>full join</literal>（全连接，并不常用）"
+msgstr "<literal>left outer join</literal>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>right outer join</literal>"
-msgstr "<literal>right outer join</literal>（右外连接）"
+msgstr "<literal>right outer join</literal>"
#. Tag: para
#, no-c-format
@@ -159,91 +111,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>inner join</literal>, <literal>left outer join</literal> and "
-"<literal>right outer join</literal> constructs may be abbreviated."
-msgstr ""
-"语句 <literal>inner join</literal>，<literal>left outer join</literal> 以及 "
-"<literal>right outer join</literal> 可以简写。"
+msgid "The <literal>inner join</literal>, <literal>left outer join</literal> and <literal>right outer join</literal> constructs may be abbreviated."
+msgstr "语句 <literal>inner join</literal>，<literal>left outer join</literal> 以及 <literal>right outer join</literal> 可以简写。"
#. Tag: para
#, no-c-format
-msgid ""
-"You may supply extra join conditions using the HQL <literal>with</literal> "
-"keyword."
-msgstr ""
-"通过 HQL 的 <literal>with</literal> 关键字，你可以提供额外的 join 条件。"
+msgid "You may supply extra join conditions using the HQL <literal>with</literal> keyword."
+msgstr "通过 HQL 的 <literal>with</literal> 关键字，你可以提供额外的 join 条件。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A \"fetch\" join allows associations or collections of values to be "
-"initialized along with their parent objects using a single select. This is "
-"particularly useful in the case of a collection. It effectively overrides "
-"the outer join and lazy declarations of the mapping file for associations "
-"and collections. See <xref linkend=\"performance-fetching\" /> for more "
-"information."
-msgstr ""
-"还有，一个 \"fetch\" 连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集"
-"合随着他们的父对象的初始化而被初始化，这种方法在使用到集合的情况下尤其有用，"
-"对于关联和集合来说，它有效的代替了映射文件中的外联接与延迟声明（lazy "
-"declarations）。查看 <xref linkend=\"Improving_performance-"
-"Fetching_strategies\"/> 以获得等多的信息。"
+#, no-c-format
+msgid "A \"fetch\" join allows associations or collections of values to be initialized along with their parent objects using a single select. This is particularly useful in the case of a collection. It effectively overrides the outer join and lazy declarations of the mapping file for associations and collections. See <xref linkend=\"performance-fetching\" /> for more information."
+msgstr "还有，一个 \"fetch\" 连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集合随着他们的父对象的初始化而被初始化，这种方法在使用到集合的情况下尤其有用，对于关联和集合来说，它有效的代替了映射文件中的外联接与延迟声明（lazy declarations）。查看 <xref linkend=\"performance-fetching\" /> 以获得等多的信息。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A fetch join does not usually need to assign an alias, because the "
-"associated objects should not be used in the <literal>where</literal> clause "
-"(or any other clause). The associated objects are also not returned directly "
-"in the query results. Instead, they may be accessed via the parent object. "
-"The only reason you might need an alias is if you are recursively join "
-"fetching a further collection:"
-msgstr ""
-"一个 fetch 连接通常不需要被指定别名，因为相关联的对象不应当被用在 "
-"<literal>where</literal> 子句（或其它任何子句）中。同时，相关联的对象并不在查"
-"询的结果中直接返回，但可以通过他们的父对象来访问到他们。"
+#, no-c-format
+msgid "A fetch join does not usually need to assign an alias, because the associated objects should not be used in the <literal>where</literal> clause (or any other clause). The associated objects are also not returned directly in the query results. Instead, they may be accessed via the parent object. The only reason you might need an alias is if you are recursively join fetching a further collection:"
+msgstr "一个 fetch 连接通常不需要被指定别名，因为相关联的对象不应当被用在 <literal>where</literal> 子句（或其它任何子句）中。同时，相关联的对象并不在查询的结果中直接返回，但可以通过他们的父对象来访问到他们。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>fetch</literal> construct cannot be used in queries called "
-"using <literal>iterate()</literal> (though <literal>scroll()</literal> can "
-"be used). <literal>Fetch</literal> should be used together with "
-"<literal>setMaxResults()</literal> or <literal>setFirstResult()</literal>, "
-"as these operations are based on the result rows which usually contain "
-"duplicates for eager collection fetching, hence, the number of rows is not "
-"what you would expect. <literal>Fetch</literal> should also not be used "
-"together with impromptu <literal>with</literal> condition. It is possible to "
-"create a cartesian product by join fetching more than one collection in a "
-"query, so take care in this case. Join fetching multiple collection roles "
-"can produce unexpected results for bag mappings, so user discretion is "
-"advised when formulating queries in this case. Finally, note that "
-"<literal>full join fetch</literal> and <literal>right join fetch</literal> "
-"are not meaningful."
-msgstr ""
-"假若使用 <literal>iterate()</literal> 来调用查询，请注意 <literal>fetch</"
-"literal> 构造是不能使用的（<literal>scroll()</literal> 可以使用）。"
-"<literal>fetch</literal> 也不应该与 <literal>setMaxResults()</literal> 或 "
-"<literal>setFirstResult()</literal> 共用，这是因为这些操作是基于结果集的，而"
-"在预先抓取集合类时可能包含重复的数据，也就是说无法预先知道精确的行数。"
-"<literal>fetch</literal> 还不能与独立的 <literal>with</literal> 条件一起使"
-"用。通过在一次查询中 fetch 多个集合，可以制造出笛卡尔积，因此请多加注意。对 "
-"bag 映射来说，同时 join fetch 多个集合角色可能在某些情况下给出并非预期的结"
-"果，也请小心。最后注意，使用 <literal>full join fetch</literal> 与 "
-"<literal>right join fetch</literal> 是没有意义的。"
+#, no-c-format
+msgid "The <literal>fetch</literal> construct cannot be used in queries called using <literal>iterate()</literal> (though <literal>scroll()</literal> can be used). <literal>Fetch</literal> should be used together with <literal>setMaxResults()</literal> or <literal>setFirstResult()</literal>, as these operations are based on the result rows which usually contain duplicates for eager collection fetching, hence, the number of rows is not what you would expect. <literal>Fetch</literal> should also not be used together with impromptu <literal>with</literal> condition. It is possible to create a cartesian product by join fetching more than one collection in a query, so take care in this case. Join fetching multiple collection roles can produce unexpected results for bag mappings, so user discretion is advised when formulating queries in this case. Finally, note that <literal>full join fetch</literal> and <literal>right join fetch</literal> are not meaningful."
+msgstr "假若使用 <literal>iterate()</literal> 来调用查询，请注意 <literal>fetch</literal> 构造是不能使用的（<literal>scroll()</literal> 可以使用）。<literal>fetch</literal> 也不应该与 <literal>setMaxResults()</literal> 或 <literal>setFirstResult()</literal> 共用，这是因为这些操作是基于结果集的，而在预先抓取集合类时可能包含重复的数据，也就是说无法预先知道精确的行数。<literal>fetch</literal> 还不能与独立的 <literal>with</literal> 条件一起使用。通过在一次查询中 fetch 多个集合，可以制造出笛卡尔积，因此请多加注意。对 bag 映射来说，同时 join fetch 多个集合角色可能在某些情况下给出并非预期的结果，也请小心。最后注意，使用 <literal>full join fetch</literal> 与 <literal>right join fetch</literal> 是没有意义的。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If you are using property-level lazy fetching (with bytecode "
-"instrumentation), it is possible to force Hibernate to fetch the lazy "
-"properties in the first query immediately using <literal>fetch all "
-"properties</literal>."
-msgstr ""
-"如果你使用属性级别的延迟获取（lazy fetching）（这是通过重新编写字节码实现"
-"的），可以使用 <literal>fetch all properties</literal> 来强制 Hibernate 立即"
-"取得那些原本需要延迟加载的属性（在第一个查询中）。"
+#, no-c-format
+msgid "If you are using property-level lazy fetching (with bytecode instrumentation), it is possible to force Hibernate to fetch the lazy properties in the first query immediately using <literal>fetch all properties</literal>."
+msgstr "如果你使用属性级别的延迟获取（lazy fetching）（这是通过重新编写字节码实现的），可以使用 <literal>fetch all properties</literal> 来强制 Hibernate 立即取得那些原本需要延迟加载的属性（在第一个查询中）。 "
#. Tag: title
#, no-c-format
@@ -252,89 +146,48 @@
#. Tag: para
#, no-c-format
-msgid ""
-"HQL supports two forms of association joining: <literal>implicit</literal> "
-"and <literal>explicit</literal>."
-msgstr ""
-"HQL 支持两种关联 join 的形式：<literal>implicit（隐式）</literal> 与 "
-"<literal>explicit（显式）</literal>。"
+msgid "HQL supports two forms of association joining: <literal>implicit</literal> and <literal>explicit</literal>."
+msgstr "HQL 支持两种关联 join 的形式：<literal>implicit（隐式）</literal> 与 <literal>explicit（显式）</literal>。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The queries shown in the previous section all use the <literal>explicit</"
-"literal> form, that is, where the join keyword is explicitly used in the "
-"from clause. This is the recommended form."
-msgstr ""
-"上一节中给出的查询都是使用 <literal>explicit（显式）</literal>形式的，其中 "
-"form 子句中明确给出了 join 关键字。这是建议使用的方式。"
+#, no-c-format
+msgid "The queries shown in the previous section all use the <literal>explicit</literal> form, that is, where the join keyword is explicitly used in the from clause. This is the recommended form."
+msgstr "上一节中给出的查询都是使用 <literal>explicit（显式）</literal>形式的，其中 form 子句中明确给出了 join 关键字。这是建议使用的方式。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>implicit</literal> form does not use the join keyword. Instead, "
-"the associations are \"dereferenced\" using dot-notation. <literal>implicit</"
-"literal> joins can appear in any of the HQL clauses. <literal>implicit</"
-"literal> join result in inner joins in the resulting SQL statement."
-msgstr ""
-"<literal>implicit（隐式）</literal>形式不使用 join 关键字。关联使用\"点号\"来"
-"进行“引用”。<literal>implicit</literal> join 可以在任何 HQL 子句中出现。"
-"<literal>implicit</literal> join 在最终的 SQL 语句中以 inner join 的方式出"
-"现。"
+msgid "The <literal>implicit</literal> form does not use the join keyword. Instead, the associations are \"dereferenced\" using dot-notation. <literal>implicit</literal> joins can appear in any of the HQL clauses. <literal>implicit</literal> join result in inner joins in the resulting SQL statement."
+msgstr "<literal>implicit（隐式）</literal>形式不使用 join 关键字。关联使用\"点号\"来进行“引用”。<literal>implicit</literal> join 可以在任何 HQL 子句中出现。<literal>implicit</literal> join 在最终的 SQL 语句中以 inner join 的方式出现。"
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Referring to identifier property"
-msgstr "引用 identifier 属性"
+msgstr "引用 identifier 属性 "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "There are 2 ways to refer to an entity's identifier property:"
-msgstr "通常有两种方法来引用实体的 identifier 属性："
+msgstr "通常有两种方法来引用实体的 identifier 属性： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The special property (lowercase) <literal>id</literal> may be used to "
-"reference the identifier property of an entity <emphasis>provided that the "
-"entity does not define a non-identifier property named id</emphasis>."
-msgstr ""
-"特殊属性（lowercase）<literal>id</literal> 可以用来引用实体的 identifier 属"
-"性 <emphasis>假设这个实体没有定义用 non-identifier 属性命名的 id</emphasis>。"
+#, no-c-format
+msgid "The special property (lowercase) <literal>id</literal> may be used to reference the identifier property of an entity <emphasis>provided that the entity does not define a non-identifier property named id</emphasis>."
+msgstr "特殊属性（lowercase）<literal>id</literal> 可以用来引用实体的 identifier 属性 <emphasis>假设这个实体没有定义用 non-identifier 属性命名的 id</emphasis>。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If the entity defines a named identifier property, you can use that property "
-"name."
-msgstr "如果这个实体定义了 identifier 属性，你可以使用属性名。"
+#, no-c-format
+msgid "If the entity defines a named identifier property, you can use that property name."
+msgstr "如果这个实体定义了 identifier 属性，你可以使用属性名。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"References to composite identifier properties follow the same naming rules. "
-"If the entity has a non-identifier property named id, the composite "
-"identifier property can only be referenced by its defined named. Otherwise, "
-"the special <literal>id</literal> property can be used to reference the "
-"identifier property."
-msgstr ""
-"对组合 identifier 属性的引用遵循相同的命名规则。如果实体有一个 non-"
-"identifier 属性命名的 id，这个组合 identifier 属性只能用自己定义的名字来引"
-"用；否则，特殊 <literal>id</literal> 属性可以用来引用 identifier 属性。"
+#, no-c-format
+msgid "References to composite identifier properties follow the same naming rules. If the entity has a non-identifier property named id, the composite identifier property can only be referenced by its defined named. Otherwise, the special <literal>id</literal> property can be used to reference the identifier property."
+msgstr "对组合 identifier 属性的引用遵循相同的命名规则。如果实体有一个 non-identifier 属性命名的 id，这个组合 identifier 属性只能用自己定义的名字来引用；否则，特殊 <literal>id</literal> 属性可以用来引用 identifier 属性。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Please note that, starting in version 3.2.2, this has changed significantly. "
-"In previous versions, <literal>id</literal> <emphasis>always</emphasis> "
-"referred to the identifier property regardless of its actual name. A "
-"ramification of that decision was that non-identifier properties named "
-"<literal>id</literal> could never be referenced in Hibernate queries."
-msgstr ""
-"注意：从 3.2.2 版本开始，这已经改变了很多。在前面的版本里，不管实际的名字，"
-"<literal>id</literal> <emphasis>总是</emphasis>指向 identifier 属性；而用 "
-"non-identifier 属性命名的 <literal>id</literal> 就从来不在 Hibernate 查询里引"
-"用。 "
+#, no-c-format
+msgid "Please note that, starting in version 3.2.2, this has changed significantly. In previous versions, <literal>id</literal> <emphasis>always</emphasis> referred to the identifier property regardless of its actual name. A ramification of that decision was that non-identifier properties named <literal>id</literal> could never be referenced in Hibernate queries."
+msgstr "注意：从 3.2.2 版本开始，这已经改变了很多。在前面的版本里，不管实际的名字，<literal>id</literal> <emphasis>总是</emphasis>指向 identifier 属性；而用 non-identifier 属性命名的 <literal>id</literal> 就从来不在 Hibernate 查询里引用。 "
#. Tag: title
#, no-c-format
@@ -342,73 +195,49 @@
msgstr "select 子句"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>select</literal> clause picks which objects and properties to "
-"return in the query result set. Consider the following:"
-msgstr ""
-"<literal>select</literal> 子句选择将哪些对象与属性返回到查询结果集中。考虑如"
-"下情况:"
+#, no-c-format
+msgid "The <literal>select</literal> clause picks which objects and properties to return in the query result set. Consider the following:"
+msgstr "<literal>select</literal> 子句选择将哪些对象与属性返回到查询结果集中。考虑如下情况："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The query will select <literal>mate</literal>s of other <literal>Cat</"
-"literal>s. You can express this query more compactly as:"
-msgstr ""
-"该语句将选择其它 <literal>Cat</literal> 的 <literal>mate</literal>（其他猫的"
-"配偶）。实际上，你可以更简洁的用以下的查询语句表达相同的含义："
+#, no-c-format
+msgid "The query will select <literal>mate</literal>s of other <literal>Cat</literal>s. You can express this query more compactly as:"
+msgstr "该语句将选择其它 <literal>Cat</literal> 的 <literal>mate</literal>（其他猫的配偶）。实际上，你可以更简洁的用以下的查询语句表达相同的含义： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Queries can return properties of any value type including properties of "
-"component type:"
-msgstr ""
-"查询语句可以返回值为任何类型的属性，包括返回类型为某种组件（Component）的属"
-"性："
+#, no-c-format
+msgid "Queries can return properties of any value type including properties of component type:"
+msgstr "查询语句可以返回值为任何类型的属性，包括返回类型为某种组件（Component）的属性： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Queries can return multiple objects and/or properties as an array of type "
-"<literal>Object[]</literal>:"
-msgstr ""
-"查询语句可以返回多个对象和（或）属性，存放在 <literal>Object[]</literal> 队列"
-"中，"
+#, no-c-format
+msgid "Queries can return multiple objects and/or properties as an array of type <literal>Object[]</literal>:"
+msgstr "查询语句可以返回多个对象和（或）属性，存放在 <literal>Object[]</literal> 队列中， "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Or as a <literal>List</literal>:"
-msgstr "或存放在一个 <literal>List</literal> 对象中，"
+msgstr "或存放在一个 <literal>List</literal> 对象中："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Or - assuming that the class <literal>Family</literal> has an appropriate "
-"constructor - as an actual typesafe Java object:"
-msgstr "假设类 <literal>Family</literal> 有一个合适的构造函数。"
+#, no-c-format
+msgid "Or - assuming that the class <literal>Family</literal> has an appropriate constructor - as an actual typesafe Java object:"
+msgstr "假设类 <literal>Family</literal> 有一个合适的构造函数 - 作为实际的类型安全的 Java 对象："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can assign aliases to selected expressions using <literal>as</literal>:"
-msgstr "你可以使用关键字 <literal>as</literal> 给“被选择了的表达式”指派别名："
+#, no-c-format
+msgid "You can assign aliases to selected expressions using <literal>as</literal>:"
+msgstr "你可以使用关键字 <literal>as</literal> 给“被选择了的表达式”指派别名： "
#. Tag: para
#, no-c-format
-msgid ""
-"This is most useful when used together with <literal>select new map</"
-"literal>:"
+msgid "This is most useful when used together with <literal>select new map</literal>:"
msgstr "这种做法在与子句 <literal>select new map</literal> 一起使用时最有用："
#. Tag: para
#, no-c-format
-msgid ""
-"This query returns a <literal>Map</literal> from aliases to selected values."
-msgstr ""
-"该查询返回了一个 <literal>Map</literal> 的对象，内容是别名与被选择的值组成的"
-"名-值映射。"
+msgid "This query returns a <literal>Map</literal> from aliases to selected values."
+msgstr "该查询返回了一个 <literal>Map</literal> 的对象，内容是别名与被选择的值组成的名-值映射。"
#. Tag: title
#, no-c-format
@@ -416,46 +245,39 @@
msgstr "聚集函数"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"HQL queries can even return the results of aggregate functions on properties:"
-msgstr "HQL 查询甚至可以返回作用于属性之上的聚集函数的计算结果："
+#, no-c-format
+msgid "HQL queries can even return the results of aggregate functions on properties:"
+msgstr "HQL 查询甚至可以返回作用于属性之上的聚集函数的计算结果： "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The supported aggregate functions are:"
-msgstr "受支持的聚集函数如下："
+msgstr "受支持的聚集函数如下： "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>avg(...), sum(...), min(...), max(...)</literal>"
-msgstr "avg(...), sum(...), min(...), max(...)"
+msgstr "<literal>avg(...), sum(...), min(...), max(...)</literal>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>count(*)</literal>"
-msgstr "或存放在一个 <literal>List</literal> 对象中，"
+msgstr "<literal>count(*)</literal>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>count(...), count(distinct ...), count(all...)</literal>"
-msgstr "count(...), count(distinct ...), count(all...)"
+msgstr "<literal>count(...), count(distinct ...), count(all...)</literal>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can use arithmetic operators, concatenation, and recognized SQL "
-"functions in the select clause:"
-msgstr "你可以在选择子句中使用数学操作符、连接以及经过验证的 SQL 函数："
+#, no-c-format
+msgid "You can use arithmetic operators, concatenation, and recognized SQL functions in the select clause:"
+msgstr "你可以在选择子句中使用数学操作符、连接以及经过验证的 SQL 函数： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>distinct</literal> and <literal>all</literal> keywords can be "
-"used and have the same semantics as in SQL."
-msgstr ""
-"关键字 <literal>distinct</literal> 与 <literal>all</literal> 也可以使用，它们"
-"具有与 SQL 相同的语义。"
+#, no-c-format
+msgid "The <literal>distinct</literal> and <literal>all</literal> keywords can be used and have the same semantics as in SQL."
+msgstr "关键字 <literal>distinct</literal> 与 <literal>all</literal> 也可以使用，它们具有与 SQL 相同的语义。 "
#. Tag: title
#, no-c-format
@@ -468,39 +290,19 @@
msgstr "一个如下的查询语句："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"returns instances not only of <literal>Cat</literal>, but also of subclasses "
-"like <literal>DomesticCat</literal>. Hibernate queries can name "
-"<emphasis>any</emphasis> Java class or interface in the <literal>from</"
-"literal> clause. The query will return instances of all persistent classes "
-"that extend that class or implement the interface. The following query would "
-"return all persistent objects:"
-msgstr ""
-"不仅返回 <literal>Cat</literal> 类的实例，也同时返回子类 "
-"<literal>DomesticCat</literal> 的实例。Hibernate 可以在 <literal>from</"
-"literal> 子句中指定<emphasis>任何</emphasis> Java 类或接口。查询会返回继承了"
-"该类的所有持久化子类的实例或返回声明了该接口的所有持久化类的实例。下面的查询"
-"语句返回所有的被持久化的对象："
+#, no-c-format
+msgid "returns instances not only of <literal>Cat</literal>, but also of subclasses like <literal>DomesticCat</literal>. Hibernate queries can name <emphasis>any</emphasis> Java class or interface in the <literal>from</literal> clause. The query will return instances of all persistent classes that extend that class or implement the interface. The following query would return all persistent objects:"
+msgstr "不仅返回 <literal>Cat</literal> 类的实例，也同时返回子类 <literal>DomesticCat</literal> 的实例。Hibernate 可以在 <literal>from</literal> 子句中指定<emphasis>任何</emphasis> Java 类或接口。查询会返回继承了该类的所有持久化子类的实例或返回声明了该接口的所有持久化类的实例。下面的查询语句返回所有的被持久化的对象： "
#. Tag: para
#, no-c-format
-msgid ""
-"The interface <literal>Named</literal> might be implemented by various "
-"persistent classes:"
+msgid "The interface <literal>Named</literal> might be implemented by various persistent classes:"
msgstr "接口 <literal>Named</literal> 可能被各种各样的持久化类声明："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"These last two queries will require more than one SQL <literal>SELECT</"
-"literal>. This means that the <literal>order by</literal> clause does not "
-"correctly order the whole result set. It also means you cannot call these "
-"queries using <literal>Query.scroll()</literal>."
-msgstr ""
-"注意，最后的两个查询将需要超过一个的 SQL <literal>SELECT</literal>。这表明 "
-"<literal>order by</literal> 子句没有对整个结果集进行正确的排序。（这也说明你"
-"不能对这样的查询使用 <literal>Query.scroll()</literal> 方法.）"
+#, no-c-format
+msgid "These last two queries will require more than one SQL <literal>SELECT</literal>. This means that the <literal>order by</literal> clause does not correctly order the whole result set. It also means you cannot call these queries using <literal>Query.scroll()</literal>."
+msgstr "注意，最后的两个查询将需要超过一个的 SQL <literal>SELECT</literal>。这表明 <literal>order by</literal> 子句没有对整个结果集进行正确的排序。（这也说明你不能对这样的查询使用 <literal>Query.scroll()</literal> 方法。）"
#. Tag: title
#, no-c-format
@@ -508,13 +310,9 @@
msgstr "where 子句"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>where</literal> clause allows you to refine the list of "
-"instances returned. If no alias exists, you can refer to properties by name:"
-msgstr ""
-"<literal>where</literal> 子句允许你将返回的实例列表的范围缩小。如果没有指定别"
-"名，你可以使用属性名来直接引用属性："
+#, no-c-format
+msgid "The <literal>where</literal> clause allows you to refine the list of instances returned. If no alias exists, you can refer to properties by name:"
+msgstr "<literal>where</literal> 子句允许你将返回的实例列表的范围缩小。如果没有指定别名，你可以使用属性名来直接引用属性： "
#. Tag: para
#, no-c-format
@@ -522,133 +320,79 @@
msgstr "如果指派了别名，需要使用完整的属性名："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "This returns instances of <literal>Cat</literal> named 'Fritz'."
-msgstr "返回名为（属性 name 等于）'Fritz' 的 <literal>Cat</literal> 类的实例。"
+msgstr "返回名为（属性 name 等于）'Fritz' 的 <literal>Cat</literal> 类的实例。 "
#. Tag: para
#, no-c-format
msgid "The following query:"
-msgstr ""
+msgstr "下面的查询："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"returns all instances of <literal>Foo</literal> with an instance of "
-"<literal>bar</literal> with a <literal>date</literal> property equal to the "
-"<literal>startDate</literal> property of the <literal>Foo</literal>. "
-"Compound path expressions make the <literal>where</literal> clause extremely "
-"powerful. Consider the following:"
-msgstr ""
-"将返回所有满足下面条件的 <literal>Foo</literal> 类的实例： 存在如下的 "
-"<literal>bar</literal> 的一个实例，其 <literal>date</literal> 属性等于 "
-"<literal>Foo</literal> 的 <literal>startDate</literal> 属性。复合路径表达式使"
-"得 <literal>where</literal> 子句非常的强大，考虑如下情况："
+#, no-c-format
+msgid "returns all instances of <literal>Foo</literal> with an instance of <literal>bar</literal> with a <literal>date</literal> property equal to the <literal>startDate</literal> property of the <literal>Foo</literal>. Compound path expressions make the <literal>where</literal> clause extremely powerful. Consider the following:"
+msgstr "将返回所有满足下面条件的 <literal>Foo</literal> 类的实例： 存在如下的 <literal>bar</literal> 的一个实例，其 <literal>date</literal> 属性等于 <literal>Foo</literal> 的 <literal>startDate</literal> 属性。复合路径表达式使得 <literal>where</literal> 子句非常的强大，考虑如下情况： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This query translates to an SQL query with a table (inner) join. For example:"
-msgstr ""
-"该查询将被翻译成为一个含有表连接（内连接）的 SQL 查询。如果你打算写像这样的查"
-"询语句"
+#, no-c-format
+msgid "This query translates to an SQL query with a table (inner) join. For example:"
+msgstr "该查询将被翻译成为一个含有表连接（内连接）的 SQL 查询。如果你打算写像这样的查询语句："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "would result in a query that would require four table joins in SQL."
-msgstr "在 SQL 中，你为达此目的将需要进行一个四表连接的查询。"
+msgstr "在 SQL 中，你为达此目的将需要进行一个四表连接的查询。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>=</literal> operator can be used to compare not only "
-"properties, but also instances:"
-msgstr ""
-"<literal>=</literal> 运算符不仅可以被用来比较属性的值，也可以用来比较实例："
+#, no-c-format
+msgid "The <literal>=</literal> operator can be used to compare not only properties, but also instances:"
+msgstr "<literal>=</literal> 运算符不仅可以被用来比较属性的值，也可以用来比较实例： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The special property (lowercase) <literal>id</literal> can be used to "
-"reference the unique identifier of an object. See <xref linkend=\"queryhql-"
-"identifier-property\" /> for more information."
-msgstr ""
-"特殊属性（小写）<literal>id</literal> 可以用来表示一个对象的唯一的标识符。详"
-"情请参考 <xref linkend=\"HQL_The_Hibernate_Query_Language-"
-"Refering_to_identifier_property\"/>。"
+#, no-c-format
+msgid "The special property (lowercase) <literal>id</literal> can be used to reference the unique identifier of an object. See <xref linkend=\"queryhql-identifier-property\" /> for more information."
+msgstr "特殊属性（小写）<literal>id</literal> 可以用来表示一个对象的唯一的标识符。详情请参考 <xref linkend=\"queryhql-identifier-property\" />。"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The second query is efficient and does not require a table join."
-msgstr "第二个查询是有效的。此时不需要进行表连接！"
+msgstr "第二个查询是有效的。此时不需要进行表连接。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Properties of composite identifiers can also be used. Consider the following "
-"example where <literal>Person</literal> has composite identifiers consisting "
-"of <literal>country</literal> and <literal>medicareNumber</literal>:"
-msgstr ""
-"同样也可以使用复合标识符。比如 <literal>Person</literal> 类有一个复合标识符，"
-"它由 <literal>country</literal> 属性与 <literal>medicareNumber</literal> 属性"
-"组成。详情请参考 <xref linkend=\"HQL_The_Hibernate_Query_Language-"
-"Refering_to_identifier_property\"/>。"
+#, no-c-format
+msgid "Properties of composite identifiers can also be used. Consider the following example where <literal>Person</literal> has composite identifiers consisting of <literal>country</literal> and <literal>medicareNumber</literal>:"
+msgstr "同样也可以使用复合标识符。比如 <literal>Person</literal> 类有一个复合标识符，它由 <literal>country</literal> 属性与 <literal>medicareNumber</literal> 属性组成："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Once again, the second query does not require a table join."
-msgstr "第二个查询也不需要进行表连接。"
+msgstr "第二个查询也不需要进行表连接。 "
#. Tag: para
#, no-c-format
-msgid ""
-"See <xref linkend=\"queryhql-identifier-property\" /> for more information "
-"regarding referencing identifier properties)"
-msgstr ""
+msgid "See <xref linkend=\"queryhql-identifier-property\" /> for more information regarding referencing identifier properties)"
+msgstr "关于引用标识符属性的更多信息，请参考 <xref linkend=\"queryhql-identifier-property\" />。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The special property <literal>class</literal> accesses the discriminator "
-"value of an instance in the case of polymorphic persistence. A Java class "
-"name embedded in the where clause will be translated to its discriminator "
-"value."
-msgstr ""
-"同样的，特殊属性 <literal>class</literal> 在进行多态持久化的情况下被用来存取"
-"一个实例的鉴别值（discriminator value）。一个嵌入到 where 子句中的 Java 类的"
-"名字将被转换为该类的鉴别值。"
+#, no-c-format
+msgid "The special property <literal>class</literal> accesses the discriminator value of an instance in the case of polymorphic persistence. A Java class name embedded in the where clause will be translated to its discriminator value."
+msgstr "同样的，特殊属性 <literal>class</literal> 在进行多态持久化的情况下被用来存取一个实例的鉴别值（discriminator value）。一个嵌入到 where 子句中的 Java 类的名字将被转换为该类的鉴别值。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can also use components or composite user types, or properties of said "
-"component types. See <xref linkend=\"queryhql-components\" /> for more "
-"information."
-msgstr ""
-"你也可以使用组件或者复合用户类型，以及组件类型的属性。详情请参考<xref "
-"linkend=\"HQL_The_Hibernate_Query_Language-Components\"/>。"
+#, no-c-format
+msgid "You can also use components or composite user types, or properties of said component types. See <xref linkend=\"queryhql-components\" /> for more information."
+msgstr "你也可以使用组件或者复合用户类型，以及组件类型的属性。详情请参考 <xref linkend=\"queryhql-components\" />。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"An \"any\" type has the special properties <literal>id</literal> and "
-"<literal>class</literal> that allows you to express a join in the following "
-"way (where <literal>AuditLog.item</literal> is a property mapped with "
-"<literal><any></literal>):"
-msgstr ""
-"一个“任意”类型有两个特殊的属性 <literal>id</literal> 和 <literal>class</"
-"literal>，来允许我们按照下面的方式表达一个连接（<literal>AuditLog.item</"
-"literal> 是一个属性，该属性被映射为 <literal><any></literal>）。"
+#, no-c-format
+msgid "An \"any\" type has the special properties <literal>id</literal> and <literal>class</literal> that allows you to express a join in the following way (where <literal>AuditLog.item</literal> is a property mapped with <literal><any></literal>):"
+msgstr "一个“任意”类型有两个特殊的属性 <literal>id</literal> 和 <literal>class</literal>，来允许我们按照下面的方式表达一个连接（<literal>AuditLog.item</literal> 是一个属性，该属性被映射为 <literal><any></literal>）。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>log.item.class</literal> and <literal>payment.class</literal> "
-"would refer to the values of completely different database columns in the "
-"above query."
-msgstr ""
-"注意，在上面的查询与句中，<literal>log.item.class</literal> 和 "
-"<literal>payment.class</literal> 将涉及到完全不同的数据库中的列。"
+#, no-c-format
+msgid "The <literal>log.item.class</literal> and <literal>payment.class</literal> would refer to the values of completely different database columns in the above query."
+msgstr "注意，在上面的查询与句中，<literal>log.item.class</literal> 和 <literal>payment.class</literal> 将涉及到完全不同的数据库中的列。"
#. Tag: title
#, no-c-format
@@ -656,26 +400,19 @@
msgstr "表达式"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Expressions used in the <literal>where</literal> clause include the "
-"following:"
-msgstr ""
-"在 <literal>where</literal> 子句中允许使用的表达式包括 大多数你可以在 SQL 使"
-"用的表达式种类："
+#, no-c-format
+msgid "Expressions used in the <literal>where</literal> clause include the following:"
+msgstr "在 <literal>where</literal> 子句中允许使用的表达式包括 大多数你可以在 SQL 使用的表达式种类： "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "mathematical operators: <literal>+, -, *, /</literal>"
-msgstr "数学运算符 <literal>+，-，*，/</literal>"
+msgstr "数学运算符 <literal>+，-，*，/</literal> "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"binary comparison operators: <literal>=, >=, <=, <>, !=, like</"
-"literal>"
-msgstr ""
-"二进制比较运算符 <literal>=, >=, <=, <>, !=, like</literal>"
+#, no-c-format
+msgid "binary comparison operators: <literal>=, >=, <=, <>, !=, like</literal>"
+msgstr "二进制比较运算符 <literal>=, >=, <=, <>, !=, like</literal> "
#. Tag: para
#, no-c-format
@@ -683,70 +420,39 @@
msgstr "逻辑运算符 <literal>and，or，not</literal>"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Parentheses <literal>( )</literal> that indicates grouping"
-msgstr "括号 <literal>( )</literal>，表示分组"
+msgstr "括号 <literal>( )</literal>，表示分组 "
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>in</literal>, <literal>not in</literal>, <literal>between</"
-"literal>, <literal>is null</literal>, <literal>is not null</literal>, "
-"<literal>is empty</literal>, <literal>is not empty</literal>, "
-"<literal>member of</literal> and <literal>not member of</literal>"
-msgstr ""
-"<literal>in</literal>, <literal>not in</literal>, <literal>between</"
-"literal>, <literal>is null</literal>, <literal>is not null</literal>, "
-"<literal>is empty</literal>, <literal>is not empty</literal>, "
-"<literal>member of</literal> and <literal>not member of</literal>"
+msgid "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
+msgstr "<literal>in</literal>, <literal>not in</literal>, <literal>between</literal>, <literal>is null</literal>, <literal>is not null</literal>, <literal>is empty</literal>, <literal>is not empty</literal>, <literal>member of</literal> and <literal>not member of</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, "
-"and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
-msgstr ""
-"\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, "
-"and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgid "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
+msgstr "\"Simple\" case, <literal>case ... when ... then ... else ... end</literal>, and \"searched\" case, <literal>case when ... then ... else ... end</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"string concatenation <literal>...||...</literal> or <literal>concat(...,...)"
-"</literal>"
-msgstr ""
-"字符串连接符 <literal>...||...</literal> or <literal>concat(...,...)</"
-"literal>"
+msgid "string concatenation <literal>...||...</literal> or <literal>concat(...,...)</literal>"
+msgstr "字符串连接符 <literal>...||...</literal> or <literal>concat(...,...)</literal>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>current_date()</literal>, <literal>current_time()</literal>, and "
-"<literal>current_timestamp()</literal>"
-msgstr ""
-"<literal>current_date()</literal>, <literal>current_time()</literal>, "
-"<literal>current_timestamp()</literal>"
+#, no-c-format
+msgid "<literal>current_date()</literal>, <literal>current_time()</literal>, and <literal>current_timestamp()</literal>"
+msgstr "<literal>current_date()</literal>, <literal>current_time()</literal>, and <literal>current_timestamp()</literal>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour"
-"(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, "
-"and <literal>year(...)</literal>"
-msgstr ""
-"<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour"
-"(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, "
-"<literal>year(...)</literal>,"
+#, no-c-format
+msgid "<literal>second(...)</literal>, <literal>minute(...)</literal>, <literal>hour(...)</literal>, <literal>day(...)</literal>, <literal>month(...)</literal>, and <literal>year(...)</literal>"
+msgstr "<literal>second(...)</literal>、<literal>minute(...)</literal>、<literal>hour(...)</literal>、<literal>day(...)</literal>、<literal>month(...)</literal> 和 <literal>year(...)</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim"
-"(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()"
-"</literal>"
-msgstr ""
-"EJB-QL 3.0 定义的任何功能或操作符：<literal>substring(), trim(), lower(), "
-"upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgid "Any function or operator defined by EJB-QL 3.0: <literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
+msgstr "EJB-QL 3.0 定义的任何功能或操作符：<literal>substring(), trim(), lower(), upper(), length(), locate(), abs(), sqrt(), bit_length(), mod()</literal>"
#. Tag: para
#, no-c-format
@@ -755,53 +461,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>str()</literal> for converting numeric or temporal values to a "
-"readable string"
+msgid "<literal>str()</literal> for converting numeric or temporal values to a readable string"
msgstr "<literal>str()</literal> 把数字或者时间值转换为可读的字符串"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>cast(... as ...)</literal>, where the second argument is the name "
-"of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI "
-"<literal>cast()</literal> and <literal>extract()</literal> is supported by "
-"the underlying database"
-msgstr ""
-"<literal>cast(... as ...)</literal>，其第二个参数是某 Hibernate 类型的名字，"
-"以及 <literal>extract(... from ...)</literal>，只要 ANSI <literal>cast()</"
-"literal> 和 <literal>extract()</literal> 被底层数据库支持"
+msgid "<literal>cast(... as ...)</literal>, where the second argument is the name of a Hibernate type, and <literal>extract(... from ...)</literal> if ANSI <literal>cast()</literal> and <literal>extract()</literal> is supported by the underlying database"
+msgstr "<literal>cast(... as ...)</literal>，其第二个参数是某 Hibernate 类型的名字，以及 <literal>extract(... from ...)</literal>，只要 ANSI <literal>cast()</literal> 和 <literal>extract()</literal> 被底层数据库支持"
#. Tag: para
#, no-c-format
-msgid ""
-"the HQL <literal>index()</literal> function, that applies to aliases of a "
-"joined indexed collection"
+msgid "the HQL <literal>index()</literal> function, that applies to aliases of a joined indexed collection"
msgstr "HQL <literal>index()</literal> 函数，作用于 join 的有序集合的别名。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"HQL functions that take collection-valued path expressions: <literal>size(), "
-"minelement(), maxelement(), minindex(), maxindex()</literal>, along with the "
-"special <literal>elements()</literal> and <literal>indices</literal> "
-"functions that can be quantified using <literal>some, all, exists, any, in</"
-"literal>."
-msgstr ""
-"HQL 函数，把集合作为参数：<literal>size(), minelement(), maxelement(), "
-"minindex(), maxindex()</literal>，还有特别的 <literal>elements()</literal> "
-"和 <literal>indices</literal> 函数，可以与数量词加以限定：<literal>some, "
-"all, exists, any, in</literal>。"
+#, no-c-format
+msgid "HQL functions that take collection-valued path expressions: <literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>, along with the special <literal>elements()</literal> and <literal>indices</literal> functions that can be quantified using <literal>some, all, exists, any, in</literal>."
+msgstr "HQL 函数，把集合作为参数：<literal>size(), minelement(), maxelement(), minindex(), maxindex()</literal>，还有特别的 <literal>elements()</literal> 和 <literal>indices</literal> 函数，可以与数量词加以限定：<literal>some, all, exists, any, in</literal>。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Any database-supported SQL scalar function like <literal>sign()</literal>, "
-"<literal>trunc()</literal>, <literal>rtrim()</literal>, and <literal>sin()</"
-"literal>"
-msgstr ""
-"任何数据库支持的 SQL 标量函数，比如 <literal>sign()</literal>, <literal>trunc"
-"()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal>"
+#, no-c-format
+msgid "Any database-supported SQL scalar function like <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, and <literal>sin()</literal>"
+msgstr "任何数据库支持的 SQL 标量函数，比如 <literal>sign()</literal>, <literal>trunc()</literal>, <literal>rtrim()</literal>, <literal>sin()</literal> "
#. Tag: para
#, no-c-format
@@ -809,160 +490,89 @@
msgstr "JDBC 风格的参数传入 <literal>?</literal>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"named parameters <literal>:name</literal>, <literal>:start_date</literal>, "
-"and <literal>:x1</literal>"
-msgstr ""
-"命名参数 <literal>:name</literal>，<literal>:start_date</literal>，<literal>:"
-"x1</literal>"
+#, no-c-format
+msgid "named parameters <literal>:name</literal>, <literal>:start_date</literal>, and <literal>:x1</literal>"
+msgstr "命名参数 <literal>:name</literal>，<literal>:start_date</literal>，<literal>:x1</literal> "
#. Tag: para
#, no-c-format
-msgid ""
-"SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E"
-"+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
-msgstr ""
-"SQL 直接常量 <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E"
-"+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgid "SQL literals <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
+msgstr "SQL 直接常量 <literal>'foo'</literal>, <literal>69</literal>, <literal>6.66E+2</literal>, <literal>'1970-01-01 10:00:01.0'</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"Java <literal>public static final</literal> constants <literal>eg.Color."
-"TABBY</literal>"
-msgstr ""
-"Java <literal>public static final</literal> 类型的常量 <literal>eg.Color."
-"TABBY</literal>"
+msgid "Java <literal>public static final</literal> constants <literal>eg.Color.TABBY</literal>"
+msgstr "Java <literal>public static final</literal> 类型的常量 <literal>eg.Color.TABBY</literal>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>in</literal> and <literal>between</literal> can be used as follows:"
-msgstr ""
-"关键字 <literal>in</literal> 与 <literal>between</literal> 可按如下方法使用："
+#, no-c-format
+msgid "<literal>in</literal> and <literal>between</literal> can be used as follows:"
+msgstr "关键字 <literal>in</literal> 与 <literal>between</literal> 可按如下方法使用： "
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The negated forms can be written as follows:"
-msgstr "而且否定的格式也可以如下书写："
+msgstr "而且否定的格式也可以如下书写： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Similarly, <literal>is null</literal> and <literal>is not null</literal> can "
-"be used to test for null values."
-msgstr ""
-"同样，子句 <literal>is null</literal> 与 <literal>is not null</literal> 可以"
-"被用来测试空值（null）。"
+#, no-c-format
+msgid "Similarly, <literal>is null</literal> and <literal>is not null</literal> can be used to test for null values."
+msgstr "同样，子句 <literal>is null</literal> 与 <literal>is not null</literal> 可以被用来测试空值（null）。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Booleans can be easily used in expressions by declaring HQL query "
-"substitutions in Hibernate configuration:"
-msgstr ""
-"在 Hibernate 配置文件中声明 HQL“查询替代（query substitutions）”之后，布尔表"
-"达式（Booleans）可以在其他表达式中轻松的使用："
+#, no-c-format
+msgid "Booleans can be easily used in expressions by declaring HQL query substitutions in Hibernate configuration:"
+msgstr "在 Hibernate 配置文件中声明 HQL“查询替代（query substitutions）”之后，布尔表达式（Booleans）可以在其他表达式中轻松的使用： "
#. Tag: para
#, no-c-format
-msgid ""
-"This will replace the keywords <literal>true</literal> and <literal>false</"
-"literal> with the literals <literal>1</literal> and <literal>0</literal> in "
-"the translated SQL from this HQL:"
-msgstr ""
-"系统将该 HQL 转换为 SQL 语句时，该设置表明将用字符 <literal>1</literal> 和 "
-"<literal>0</literal> 来取代关键字 <literal>true</literal> 和 <literal>false</"
-"literal>："
+msgid "This will replace the keywords <literal>true</literal> and <literal>false</literal> with the literals <literal>1</literal> and <literal>0</literal> in the translated SQL from this HQL:"
+msgstr "系统将该 HQL 转换为 SQL 语句时，该设置表明将用字符 <literal>1</literal> 和 <literal>0</literal> 来取代关键字 <literal>true</literal> 和 <literal>false</literal>："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can test the size of a collection with the special property "
-"<literal>size</literal> or the special <literal>size()</literal> function."
-msgstr ""
-"你可以用特殊属性 <literal>size</literal>，或是特殊函数 <literal>size()</"
-"literal> 测试一个集合的大小。"
+#, no-c-format
+msgid "You can test the size of a collection with the special property <literal>size</literal> or the special <literal>size()</literal> function."
+msgstr "你可以用特殊属性 <literal>size</literal>，或是特殊函数 <literal>size()</literal> 测试一个集合的大小。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For indexed collections, you can refer to the minimum and maximum indices "
-"using <literal>minindex</literal> and <literal>maxindex</literal> functions. "
-"Similarly, you can refer to the minimum and maximum elements of a collection "
-"of basic type using the <literal>minelement</literal> and "
-"<literal>maxelement</literal> functions. For example:"
-msgstr ""
-"对于索引了（有序）的集合，你可以使用 <literal>minindex</literal> 与 "
-"<literal>maxindex</literal> 函数来引用到最小与最大的索引序数。同理，你可以使"
-"用 <literal>minelement</literal> 与 <literal>maxelement</literal> 函数来引用"
-"到一个基本数据类型的集合中最小与最大的元素。"
+#, no-c-format
+msgid "For indexed collections, you can refer to the minimum and maximum indices using <literal>minindex</literal> and <literal>maxindex</literal> functions. Similarly, you can refer to the minimum and maximum elements of a collection of basic type using the <literal>minelement</literal> and <literal>maxelement</literal> functions. For example:"
+msgstr "对于索引了（有序）的集合，你可以使用 <literal>minindex</literal> 与 <literal>maxindex</literal> 函数来引用到最小与最大的索引序数。同理，你可以使用 <literal>minelement</literal> 与 <literal>maxelement</literal> 函数来引用到一个基本数据类型的集合中最小与最大的元素。例如："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The SQL functions <literal>any, some, all, exists, in</literal> are "
-"supported when passed the element or index set of a collection "
-"(<literal>elements</literal> and <literal>indices</literal> functions) or "
-"the result of a subquery (see below):"
-msgstr ""
-"在传递一个集合的索引集或者是元素集（<literal>elements</literal> 与 "
-"<literal>indices</literal> 函数）或者传递一个子查询的结果的时候，可以使用 "
-"SQL 函数 <literal>any, some，all, exists, in</literal>"
+#, no-c-format
+msgid "The SQL functions <literal>any, some, all, exists, in</literal> are supported when passed the element or index set of a collection (<literal>elements</literal> and <literal>indices</literal> functions) or the result of a subquery (see below):"
+msgstr "在传递一个集合的索引集或者是元素集（<literal>elements</literal> 与 <literal>indices</literal> 函数）或者传递一个子查询的结果的时候，可以使用 SQL 函数 <literal>any, some，all, exists, in</literal>："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Note that these constructs - <literal>size</literal>, <literal>elements</"
-"literal>, <literal>indices</literal>, <literal>minindex</literal>, "
-"<literal>maxindex</literal>, <literal>minelement</literal>, "
-"<literal>maxelement</literal> - can only be used in the where clause in "
-"Hibernate3."
-msgstr ""
-"注意，在 Hibernate3 中，这些结构变量 — <literal>size</literal>，"
-"<literal>elements</literal>，<literal>indices</literal>，<literal>minindex</"
-"literal>，<literal>maxindex</literal>，<literal>minelement</literal>，"
-"<literal>maxelement</literal> — 只能在 where 子句中使用。"
+#, no-c-format
+msgid "Note that these constructs - <literal>size</literal>, <literal>elements</literal>, <literal>indices</literal>, <literal>minindex</literal>, <literal>maxindex</literal>, <literal>minelement</literal>, <literal>maxelement</literal> - can only be used in the where clause in Hibernate3."
+msgstr "注意，在 Hibernate3 中，这些结构变量 — <literal>size</literal>，<literal>elements</literal>，<literal>indices</literal>，<literal>minindex</literal>，<literal>maxindex</literal>，<literal>minelement</literal>，<literal>maxelement</literal> — 只能在 where 子句中使用。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Elements of indexed collections (arrays, lists, and maps) can be referred to "
-"by index in a where clause only:"
-msgstr ""
-"一个被索引过的（有序的）集合的元素（arrays，lists，maps）可以在其他索引中被引"
-"用（只能在 where 子句中）："
+#, no-c-format
+msgid "Elements of indexed collections (arrays, lists, and maps) can be referred to by index in a where clause only:"
+msgstr "一个被索引过的（有序的）集合的元素（arrays，lists，maps）可以在其他索引中被引用（只能在 where 子句中）： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The expression inside <literal>[]</literal> can even be an arithmetic "
-"expression:"
-msgstr "在 <literal>[]</literal> 中的表达式甚至可以是一个算数表达式。"
+#, no-c-format
+msgid "The expression inside <literal>[]</literal> can even be an arithmetic expression:"
+msgstr "在 <literal>[]</literal> 中的表达式甚至可以是一个算数表达式："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"HQL also provides the built-in <literal>index()</literal> function for "
-"elements of a one-to-many association or collection of values."
-msgstr ""
-"对于一个一对多的关联（one-to-many association）或是值的集合中的元素，HQL 也提"
-"供内建的 <literal>index()</literal> 函数，"
+#, no-c-format
+msgid "HQL also provides the built-in <literal>index()</literal> function for elements of a one-to-many association or collection of values."
+msgstr "对于一个一对多的关联（one-to-many association）或是值的集合中的元素，HQL 也提供内建的 <literal>index()</literal> 函数。"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Scalar SQL functions supported by the underlying database can be used:"
-msgstr "如果底层数据库支持标量的 SQL 函数，它们也可以被使用"
+msgstr "如果底层数据库支持标量的 SQL 函数，它们也可以被使用："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Consider how much longer and less readable the following query would be in "
-"SQL:"
-msgstr ""
-"如果你还不能对所有的这些深信不疑，想想下面的查询。如果使用 SQL，语句长度会增"
-"长多少，可读性会下降多少："
+#, no-c-format
+msgid "Consider how much longer and less readable the following query would be in SQL:"
+msgstr "如果你还不能对所有的这些深信不疑，想想下面的查询。如果使用 SQL，语句长度会增长多少，可读性会下降多少： "
#. Tag: para
#, no-c-format
@@ -975,22 +585,14 @@
msgstr "order by 子句"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The list returned by a query can be ordered by any property of a returned "
-"class or components:"
-msgstr ""
-"查询返回的列表（list）可以按照一个返回的类或组件（components）中的任何属性"
-"（property）进行排序："
+#, no-c-format
+msgid "The list returned by a query can be ordered by any property of a returned class or components:"
+msgstr "查询返回的列表（list）可以按照一个返回的类或组件（components）中的任何属性（property）进行排序： "
#. Tag: para
#, no-c-format
-msgid ""
-"The optional <literal>asc</literal> or <literal>desc</literal> indicate "
-"ascending or descending order respectively."
-msgstr ""
-"可选的 <literal>asc</literal> 或 <literal>desc</literal> 关键字指明了按照升序"
-"或降序进行排序。"
+msgid "The optional <literal>asc</literal> or <literal>desc</literal> indicate ascending or descending order respectively."
+msgstr "可选的 <literal>asc</literal> 或 <literal>desc</literal> 关键字指明了按照升序或降序进行排序。"
#. Tag: title
#, no-c-format
@@ -998,13 +600,9 @@
msgstr "group by 子句"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A query that returns aggregate values can be grouped by any property of a "
-"returned class or components:"
-msgstr ""
-"一个返回聚集值（aggregate values）的查询可以按照一个返回的类或组件"
-"（components）中的任何属性（property）进行分组："
+#, no-c-format
+msgid "A query that returns aggregate values can be grouped by any property of a returned class or components:"
+msgstr "一个返回聚集值（aggregate values）的查询可以按照一个返回的类或组件（components）中的任何属性（property）进行分组： "
#. Tag: para
#, no-c-format
@@ -1012,30 +610,14 @@
msgstr "<literal>having</literal> 子句在这里也允许使用。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"SQL functions and aggregate functions are allowed in the <literal>having</"
-"literal> and <literal>order by</literal> clauses if they are supported by "
-"the underlying database (i.e., not in MySQL)."
-msgstr ""
-"如果底层的数据库支持的话（例如不能在 MySQL 中使用），SQL 的一般函数与聚集函数"
-"也可以出现在 <literal>having</literal> 与 <literal>order by</literal> 子句"
-"中。"
+#, no-c-format
+msgid "SQL functions and aggregate functions are allowed in the <literal>having</literal> and <literal>order by</literal> clauses if they are supported by the underlying database (i.e., not in MySQL)."
+msgstr "如果底层的数据库支持的话（例如不能在 MySQL 中使用），SQL 的一般函数与聚集函数也可以出现在 <literal>having</literal> 与 <literal>order by</literal> 子句中。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Neither the <literal>group by</literal> clause nor the <literal>order by</"
-"literal> clause can contain arithmetic expressions. Hibernate also does not "
-"currently expand a grouped entity, so you cannot write <literal>group by "
-"cat</literal> if all properties of <literal>cat</literal> are non-"
-"aggregated. You have to list all non-aggregated properties explicitly."
-msgstr ""
-"注意 <literal>group by</literal> 子句与 <literal>order by</literal> 子句中都"
-"不能包含算术表达式（arithmetic expressions）。也要注意 Hibernate 目前不会扩"
-"展 group 的实体，因此你不能写 <literal>group by cat</literal>，除非 "
-"<literal>cat</literal> 的所有属性都不是聚集的（non-aggregated）。你必须明确的"
-"列出所有的非聚集属性。"
+#, no-c-format
+msgid "Neither the <literal>group by</literal> clause nor the <literal>order by</literal> clause can contain arithmetic expressions. Hibernate also does not currently expand a grouped entity, so you cannot write <literal>group by cat</literal> if all properties of <literal>cat</literal> are non-aggregated. You have to list all non-aggregated properties explicitly."
+msgstr "注意 <literal>group by</literal> 子句与 <literal>order by</literal> 子句中都不能包含算术表达式（arithmetic expressions）。也要注意 Hibernate 目前不会扩展 group 的实体，因此你不能写 <literal>group by cat</literal>，除非 <literal>cat</literal> 的所有属性都不是聚集的（non-aggregated）。你必须明确的列出所有的非聚集属性。 "
#. Tag: title
#, no-c-format
@@ -1044,31 +626,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"For databases that support subselects, Hibernate supports subqueries within "
-"queries. A subquery must be surrounded by parentheses (often by an SQL "
-"aggregate function call). Even correlated subqueries (subqueries that refer "
-"to an alias in the outer query) are allowed."
-msgstr ""
-"对于支持子查询的数据库，Hibernate 支持在查询中使用子查询。一个子查询必须被圆"
-"括号包围起来（经常是 SQL 聚集函数的圆括号）。甚至相互关联的子查询（引用到外部"
-"查询中的别名的子查询）也是允许的。"
+msgid "For databases that support subselects, Hibernate supports subqueries within queries. A subquery must be surrounded by parentheses (often by an SQL aggregate function call). Even correlated subqueries (subqueries that refer to an alias in the outer query) are allowed."
+msgstr "对于支持子查询的数据库，Hibernate 支持在查询中使用子查询。一个子查询必须被圆括号包围起来（经常是 SQL 聚集函数的圆括号）。甚至相互关联的子查询（引用到外部查询中的别名的子查询）也是允许的。"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Note that HQL subqueries can occur only in the select or where clauses."
-msgstr "注意，HQL 自查询只可以在 select 或者 where 子句中出现。"
+msgstr "注意，HQL 自查询只可以在 select 或者 where 子句中出现。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Note that subqueries can also utilize <literal>row value constructor</"
-"literal> syntax. See <xref linkend=\"queryhql-tuple\" /> for more "
-"information."
-msgstr ""
-"注意子查询也可以利用 <literal>row value constructor</literal> 语法。请参考 "
-"<xref linkend=\"HQL_The_Hibernate_Query_Language-Row_value_constructor_syntax"
-"\"/> 来获得详情。 "
+#, no-c-format
+msgid "Note that subqueries can also utilize <literal>row value constructor</literal> syntax. See <xref linkend=\"queryhql-tuple\" /> for more information."
+msgstr "注意子查询也可以利用 <literal>row value constructor</literal> 语法。请参考 <xref linkend=\"queryhql-tuple\" /> 来获得详情。 "
#. Tag: title
#, no-c-format
@@ -1076,91 +645,38 @@
msgstr "HQL 示例 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate queries can be quite powerful and complex. In fact, the power of "
-"the query language is one of Hibernate's main strengths. The following "
-"example queries are similar to queries that have been used on recent "
-"projects. Please note that most queries you will write will be much simpler "
-"than the following examples."
-msgstr ""
-"Hibernate 查询可以非常的强大与复杂。实际上，Hibernate 的一个主要卖点就是查询"
-"语句的威力。这里有一些例子，它们与我在最近的一个项目中使用的查询非常相似。注"
-"意你能用到的大多数查询比这些要简单的多！"
+#, no-c-format
+msgid "Hibernate queries can be quite powerful and complex. In fact, the power of the query language is one of Hibernate's main strengths. The following example queries are similar to queries that have been used on recent projects. Please note that most queries you will write will be much simpler than the following examples."
+msgstr "Hibernate 查询可以非常的强大与复杂。实际上，Hibernate 的一个主要卖点就是查询语句的威力。这里有一些例子，它们与我在最近的一个项目中使用的查询非常相似。注意你能用到的大多数查询比这些要简单的多。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The following query returns the order id, number of items, the given minimum "
-"total value and the total value of the order for all unpaid orders for a "
-"particular customer. The results are ordered by total value. In determining "
-"the prices, it uses the current catalog. The resulting SQL query, against "
-"the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, "
-"<literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</"
-"literal> tables has four inner joins and an (uncorrelated) subselect."
-msgstr ""
-"下面的查询对于某个特定的客户的所有未支付的账单，在给定给最小总价值的情况下，"
-"返回订单的 id，条目的数量和总价值，返回值按照总价值的结果进行排序。为了决定价"
-"格，查询使用了当前目录。作为转换结果的 SQL 查询，使用了<literal>ORDER</"
-"literal>，<literal>ORDER_LINE</literal>，<literal>PRODUCT</literal>，"
-"<literal>CATALOG</literal> 和 <literal>PRICE</literal> 库表。"
+#, no-c-format
+msgid "The following query returns the order id, number of items, the given minimum total value and the total value of the order for all unpaid orders for a particular customer. The results are ordered by total value. In determining the prices, it uses the current catalog. The resulting SQL query, against the <literal>ORDER</literal>, <literal>ORDER_LINE</literal>, <literal>PRODUCT</literal>, <literal>CATALOG</literal> and <literal>PRICE</literal> tables has four inner joins and an (uncorrelated) subselect."
+msgstr "下面的查询对于某个特定的客户的所有未支付的账单，在给定给最小总价值的情况下，返回订单的 id，条目的数量和总价值，返回值按照总价值的结果进行排序。为了决定价格，查询使用了当前目录。作为转换结果的 SQL 查询，使用了<literal>ORDER</literal>，<literal>ORDER_LINE</literal>，<literal>PRODUCT</literal>，<literal>CATALOG</literal> 和 <literal>PRICE</literal> 库表。"
#. Tag: para
#, no-c-format
-msgid ""
-"What a monster! Actually, in real life, I'm not very keen on subqueries, so "
-"my query was really more like this:"
-msgstr ""
-"这简直是一个怪物！实际上，在现实生活中，我并不热衷于子查询，所以我的查询语句"
-"看起来更像这个："
+msgid "What a monster! Actually, in real life, I'm not very keen on subqueries, so my query was really more like this:"
+msgstr "这简直是一个怪物！实际上，在现实生活中，我并不热衷于子查询，所以我的查询语句看起来更像这个："
#. Tag: para
#, no-c-format
-msgid ""
-"The next query counts the number of payments in each status, excluding all "
-"payments in the <literal>AWAITING_APPROVAL</literal> status where the most "
-"recent status change was made by the current user. It translates to an SQL "
-"query with two inner joins and a correlated subselect against the "
-"<literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and "
-"<literal>PAYMENT_STATUS_CHANGE</literal> tables."
-msgstr ""
-"下面一个查询计算每一种状态下的支付的数目，除去所有处于 "
-"<literal>AWAITING_APPROVAL</literal> 状态的支付，因为在该状态下 当前的用户作"
-"出了状态的最新改变。该查询被转换成含有两个内连接以及一个相关联的子选择的 SQL "
-"查询，该查询使用了表 <literal>PAYMENT</literal>，<literal>PAYMENT_STATUS</"
-"literal> 以及 <literal>PAYMENT_STATUS_CHANGE</literal>。"
+msgid "The next query counts the number of payments in each status, excluding all payments in the <literal>AWAITING_APPROVAL</literal> status where the most recent status change was made by the current user. It translates to an SQL query with two inner joins and a correlated subselect against the <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal> and <literal>PAYMENT_STATUS_CHANGE</literal> tables."
+msgstr "下面一个查询计算每一种状态下的支付的数目，除去所有处于 <literal>AWAITING_APPROVAL</literal> 状态的支付，因为在该状态下 当前的用户作出了状态的最新改变。该查询被转换成含有两个内连接以及一个相关联的子选择的 SQL 查询，该查询使用了表 <literal>PAYMENT</literal>，<literal>PAYMENT_STATUS</literal> 以及 <literal>PAYMENT_STATUS_CHANGE</literal>。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If the <literal>statusChanges</literal> collection was mapped as a list, "
-"instead of a set, the query would have been much simpler to write."
-msgstr ""
-"如果我把 <literal>statusChanges</literal> 实例集映射为一个列表（list）而不是"
-"一个集合（set），书写查询语句将更加简单。"
+#, no-c-format
+msgid "If the <literal>statusChanges</literal> collection was mapped as a list, instead of a set, the query would have been much simpler to write."
+msgstr "如果我把 <literal>statusChanges</literal> 实例集映射为一个列表（list）而不是一个集合（set），书写查询语句将更加简单。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The next query uses the MS SQL Server <literal>isNull()</literal> function "
-"to return all the accounts and unpaid payments for the organization to which "
-"the current user belongs. It translates to an SQL query with three inner "
-"joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, "
-"<literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, "
-"<literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and "
-"<literal>ORG_USER</literal> tables."
-msgstr ""
-"下面一个查询使用了 MS SQL Server 的 <literal>isNull()</literal> 函数用以返回"
-"当前用户所属组织的组织帐号及组织未支付的账。它被转换成一个对表 "
-"<literal>ACCOUNT</literal>，<literal>PAYMENT</literal>，"
-"<literal>PAYMENT_STATUS</literal>，<literal>ACCOUNT_TYPE</literal>，"
-"<literal>ORGANIZATION</literal> 以及 <literal>ORG_USER</literal> 进行的三个"
-"内连接，一个外连接和一个子选择的 SQL 查询。"
+msgid "The next query uses the MS SQL Server <literal>isNull()</literal> function to return all the accounts and unpaid payments for the organization to which the current user belongs. It translates to an SQL query with three inner joins, an outer join and a subselect against the <literal>ACCOUNT</literal>, <literal>PAYMENT</literal>, <literal>PAYMENT_STATUS</literal>, <literal>ACCOUNT_TYPE</literal>, <literal>ORGANIZATION</literal> and <literal>ORG_USER</literal> tables."
+msgstr "下面一个查询使用了 MS SQL Server 的 <literal>isNull()</literal> 函数用以返回当前用户所属组织的组织帐号及组织未支付的账。它被转换成一个对表 <literal>ACCOUNT</literal>，<literal>PAYMENT</literal>，<literal>PAYMENT_STATUS</literal>，<literal>ACCOUNT_TYPE</literal>，<literal>ORGANIZATION</literal> 以及 <literal>ORG_USER</literal> 进行的三个内连接，一个外连接和一个子选择的 SQL 查询。"
#. Tag: para
#, no-c-format
-msgid ""
-"For some databases, we would need to do away with the (correlated) subselect."
+msgid "For some databases, we would need to do away with the (correlated) subselect."
msgstr "对于一些数据库，我们需要弃用（相关的）子选择。"
#. Tag: title
@@ -1169,15 +685,9 @@
msgstr "批量的 UPDATE 和 DELETE"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"HQL now supports <literal>update</literal>, <literal>delete</literal> and "
-"<literal>insert ... select ...</literal> statements. See <xref linkend="
-"\"batch-direct\" /> for more information."
-msgstr ""
-"HQL 现在支持 <literal>update</literal>，<literal>delete</literal> 和 "
-"<literal>insert ... select ...</literal>语句。查阅 <xref linkend="
-"\"Batch_processing-DML_style_operations\"/> 以获得更多信息。"
+#, no-c-format
+msgid "HQL now supports <literal>update</literal>, <literal>delete</literal> and <literal>insert ... select ...</literal> statements. See <xref linkend=\"batch-direct\" /> for more information."
+msgstr "HQL 现在支持 <literal>update</literal>，<literal>delete</literal> 和 <literal>insert ... select ...</literal>语句。查阅 <xref linkend=\"batch-direct\" /> 以获得更多信息。"
#. Tag: title
#, no-c-format
@@ -1185,9 +695,9 @@
msgstr "小技巧 & 小窍门"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "You can count the number of query results without returning them:"
-msgstr "你可以统计查询结果的数目而不必实际的返回他们："
+msgstr "你可以统计查询结果的数目而不必实际的返回他们： "
#. Tag: para
#, no-c-format
@@ -1196,26 +706,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If your database supports subselects, you can place a condition upon "
-"selection size in the where clause of your query:"
-msgstr ""
-"如果你的数据库支持子选择，你可以在你的查询的 where 子句中为选择的大小"
-"（selection size）指定一个条件："
+msgid "If your database supports subselects, you can place a condition upon selection size in the where clause of your query:"
+msgstr "如果你的数据库支持子选择，你可以在你的查询的 where 子句中为选择的大小（selection size）指定一个条件："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "If your database does not support subselects, use the following query:"
-msgstr "如果你的数据库不支持子选择语句，使用下面的查询："
+msgstr "如果你的数据库不支持子选择语句，使用下面的查询： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"As this solution cannot return a <literal>User</literal> with zero messages "
-"because of the inner join, the following form is also useful:"
-msgstr ""
-"因为内连接（inner join）的原因，这个解决方案不能返回含有零个信息的 "
-"<literal>User</literal> 类的实例，所以这种情况下使用下面的格式将是有帮助的："
+#, no-c-format
+msgid "As this solution cannot return a <literal>User</literal> with zero messages because of the inner join, the following form is also useful:"
+msgstr "因为内连接（inner join）的原因，这个解决方案不能返回含有零个信息的 <literal>User</literal> 类的实例，所以这种情况下使用下面的格式将是有帮助的： "
#. Tag: para
#, no-c-format
@@ -1224,18 +726,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Collections are pageable by using the <literal>Query</literal> interface "
-"with a filter:"
-msgstr ""
-"通过将接口 <literal>Query</literal> 与一个过滤器（filter）一起使用，集合"
-"（Collections）是可以分页的："
+msgid "Collections are pageable by using the <literal>Query</literal> interface with a filter:"
+msgstr "通过将接口 <literal>Query</literal> 与一个过滤器（filter）一起使用，集合（Collections）是可以分页的："
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Collection elements can be ordered or grouped using a query filter:"
-msgstr ""
-"通过使用查询过滤器（query filter）可以将集合（Collection）的元素分组或排序："
+msgstr "通过使用查询过滤器（query filter）可以将集合（Collection）的元素分组或排序： "
#. Tag: para
#, no-c-format
@@ -1248,23 +745,14 @@
msgstr "组件"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Components can be used similarly to the simple value types that are used in "
-"HQL queries. They can appear in the <literal>select</literal> clause as "
-"follows:"
-msgstr ""
-"在 HQL 查询里，组件可以和简单值类型一样使用。它们可以出现在 <literal>select</"
-"literal> 子句里："
+#, no-c-format
+msgid "Components can be used similarly to the simple value types that are used in HQL queries. They can appear in the <literal>select</literal> clause as follows:"
+msgstr "在 HQL 查询里，组件可以和简单值类型一样使用。它们可以出现在 <literal>select</literal> 子句里： "
#. Tag: para
#, no-c-format
-msgid ""
-"where the Person's name property is a component. Components can also be used "
-"in the <literal>where</literal> clause:"
-msgstr ""
-"在这里，Person 的 name 属性是一个组件。组件也可以用在 <literal>where</"
-"literal> 子句里："
+msgid "where the Person's name property is a component. Components can also be used in the <literal>where</literal> clause:"
+msgstr "在这里，Person 的 name 属性是一个组件。组件也可以用在 <literal>where</literal> 子句里："
#. Tag: para
#, no-c-format
@@ -1272,12 +760,9 @@
msgstr "组件也可以用在 <literal>order by</literal> 子句里："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Another common use of components is in <xref linkend=\"queryhql-tuple\" />."
-msgstr ""
-"组件的另外一个常见用法是在 <xref linkend=\"HQL_The_Hibernate_Query_Language-"
-"Row_value_constructor_syntax\"/> 行值（row value）构造函数里。"
+#, no-c-format
+msgid "Another common use of components is in <xref linkend=\"queryhql-tuple\" />."
+msgstr "组件的另外一个常见用法是在 <xref linkend=\"queryhql-tuple\" /> 行值（row value）构造函数里。"
#. Tag: title
#, no-c-format
@@ -1285,53 +770,29 @@
msgstr "Row value 构造函数语法"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"HQL supports the use of ANSI SQL <literal>row value constructor</literal> "
-"syntax, sometimes referred to AS <literal>tuple</literal> syntax, even "
-"though the underlying database may not support that notion. Here, we are "
-"generally referring to multi-valued comparisons, typically associated with "
-"components. Consider an entity Person which defines a name component:"
-msgstr ""
-"HQL 支持 ANSI SQL <literal>row value constructor</literal> 语法（有时也叫作 "
-"<literal>tuple</literal> 语法），即使底层数据库可能不支持这个概念。在这里我们"
-"通常指的是多值（multi-valued）的比较，典型地是和组件相关联。来看看一个定义了 "
-"name 组件的实体 Person： "
+#, no-c-format
+msgid "HQL supports the use of ANSI SQL <literal>row value constructor</literal> syntax, sometimes referred to AS <literal>tuple</literal> syntax, even though the underlying database may not support that notion. Here, we are generally referring to multi-valued comparisons, typically associated with components. Consider an entity Person which defines a name component:"
+msgstr "HQL 支持 ANSI SQL <literal>row value constructor</literal> 语法（有时也叫作 <literal>tuple</literal> 语法），即使底层数据库可能不支持这个概念。在这里我们通常指的是多值（multi-valued）的比较，典型地是和组件相关联。来看看一个定义了 name 组件的实体 Person："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"That is valid syntax although it is a little verbose. You can make this more "
-"concise by using <literal>row value constructor</literal> syntax:"
-msgstr ""
-"那是有效的语法，虽然有点冗长。我们可以使它更加简洁一点，并使用 <literal>row "
-"value constructor</literal> 语法："
+#, no-c-format
+msgid "That is valid syntax although it is a little verbose. You can make this more concise by using <literal>row value constructor</literal> syntax:"
+msgstr "那是有效的语法，虽然有点冗长。我们可以使它更加简洁一点，并使用 <literal>row value constructor</literal> 语法： "
#. Tag: para
#, no-c-format
-msgid ""
-"It can also be useful to specify this in the <literal>select</literal> "
-"clause:"
+msgid "It can also be useful to specify this in the <literal>select</literal> clause:"
msgstr "在 <literal>select</literal> 子句里指定这个也是很有用的："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Using <literal>row value constructor</literal> syntax can also be beneficial "
-"when using subqueries that need to compare against multiple values:"
-msgstr ""
-"当使用需要比较多个值的子查询时，采用 <literal>row value constructor</"
-"literal> 语法也很有用处："
+#, no-c-format
+msgid "Using <literal>row value constructor</literal> syntax can also be beneficial when using subqueries that need to compare against multiple values:"
+msgstr "当使用需要比较多个值的子查询时，采用 <literal>row value constructor</literal> 语法也很有用处： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"One thing to consider when deciding if you want to use this syntax, is that "
-"the query will be dependent upon the ordering of the component sub-"
-"properties in the metadata."
-msgstr ""
-"决定是否使用这个语法的一件因素就是：这个查询将依赖于元数据里的组件子属性"
-"（sub-properties）的顺序。"
+#, no-c-format
+msgid "One thing to consider when deciding if you want to use this syntax, is that the query will be dependent upon the ordering of the component sub-properties in the metadata."
+msgstr "决定是否使用这个语法的一件因素就是：这个查询将依赖于元数据里的组件子属性（sub-properties）的顺序。 "
#, fuzzy
#~ msgid "<![CDATA[from eg.Cat]]>"
@@ -1370,10 +831,8 @@
#, fuzzy
#~ msgid "<![CDATA[from Formula form full join form.parameter param]]>"
#~ msgstr "from Formula form full join form.parameter param"
-
#~ msgid "inner join"
#~ msgstr "<literal>inner join</literal>（内连接）"
-
#~ msgid "left outer join"
#~ msgstr "<literal>left outer join</literal>（左外连接）"
@@ -1524,7 +983,6 @@
#~ msgstr ""
#~ "select avg(cat.weight), sum(cat.weight), max(cat.weight), count(cat)\n"
#~ "from Cat cat"
-
#~ msgid "count(*)"
#~ msgstr "count(*)"
@@ -2264,3 +1722,4 @@
#~ "where not ( cat.name, cat.color ) in (\n"
#~ " select cat.name, cat.color from DomesticCat cat\n"
#~ ")"
+
More information about the jboss-cvs-commits
mailing list