[jboss-cvs] JBossAS SVN: r97708 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.

[jboss-cvs-commits at lists.jboss.org]

Author: xhuang at jboss.com
Date: 2009-12-10 19:50:05 -0500 (Thu, 10 Dec 2009)
New Revision: 97708

Modified:
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Feedback.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Revision_History.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/component_mapping.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/portability.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/preface.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_sql.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po
   projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po
Log:
update

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Feedback.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Feedback.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Feedback.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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:25\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-12-11 09:49+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -17,17 +17,10 @@
 #. Tag: title
 #, no-c-format
 msgid "Feedback"
-msgstr ""
+msgstr "反馈"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you spot a typo in this guide, or if you have thought of a way to make "
-"this manual better, we would love to hear from you! Submit a report in "
-"<ulink url=\"http://jira.jboss.com/jira/browse/JBPAPP\">JIRA</ulink> against "
-"the Product: JBoss Enterprise Application Platform, Version: "
-"<replaceable>&lt;version&gt;</replaceable>, Component: <emphasis>Doc</"
-"emphasis>. If you have a suggestion for improving the documentation, try to "
-"be as specific as possible. If you have found an error, include the section "
-"number and some of the surrounding text so we can find it easily."
-msgstr ""
+msgid "If you spot a typo in this guide, or if you have thought of a way to make this manual better, we would love to hear from you! Submit a report in <ulink url=\"http://jira.jboss.com/jira/browse/JBPAPP\">JIRA</ulink> against the Product: JBoss Enterprise Application Platform, Version: <replaceable>&lt;version&gt;</replaceable>, Component: <emphasis>Doc</emphasis>. If you have a suggestion for improving the documentation, try to be as specific as possible. If you have found an error, include the section number and some of the surrounding text so we can find it easily."
+msgstr "å¦‚æžœä½ åœ¨æœ¬æŒ‡å—é‡Œå‘çŽ°äº†å°åˆ·é”™è¯¯ï¼Œæˆ–è€…ä½ æœ‰æ”¹è¿›è¯¥æ‰‹å†Œçš„å»ºè®®ï¼Œæˆ‘ä»¬å¸Œæœ›å¬åˆ°ä½ çš„å£°éŸ³ï¼è¯·æäº¤æŠ¥å‘Šåˆ° <ulink url=\"http://jira.jboss.com/jira/browse/JBPAPP\">JIRA</ulink> 并指明：产品：JBoss 企业级应用程序平台, 版本：<replaceable>&lt;version&gt;</replaceable>，组件：<emphasis>Doc</emphasis>ã€‚å¦‚æžœæ˜¯æ”¹è¿›æœ¬æ–‡æ¡£çš„å»ºè®®ï¼Œè¯·å°½é‡å…·ä½“åŒ–ï¼›å¦‚æžœæ˜¯å…¶ä»–é”™è¯¯ï¼Œè¯·æŒ‡å‡ºç« èŠ‚å·ä»¥åŠå…·ä½“çš„å†…å®¹ï¼Œè¿™æ ·æˆ‘ä»¬å°±å¯ä»¥å°½å¿«æ”¹æ­£ã€‚"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Revision_History.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Revision_History.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/Revision_History.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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:25\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-12-11 09:55+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -17,9 +17,10 @@
 #. Tag: title
 #, no-c-format
 msgid "Revision History"
-msgstr ""
+msgstr "修订历史记录"
 
 #. Tag: member
 #, no-c-format
 msgid "Initial draft."
-msgstr ""
+msgstr "初始草稿"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/architecture.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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:25\n"
-"PO-Revision-Date: 2009-11-02 14:57+1000\n"
+"PO-Revision-Date: 2009-12-11 09:06+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -26,50 +26,28 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The diagram below provides a high-level view of the Hibernate architecture:"
+msgid "The diagram below provides a high-level view of the Hibernate architecture:"
 msgstr "下面的图表提供了 Hibernate 体系结构的高层视图："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"We do not have the scope in this document to provide a more detailed view of "
-"all the runtime architectures available; Hibernate is flexible and supports "
-"several different approaches. We will, however, show the two extremes: "
-"\"minimal\" architecture and \"comprehensive\" architecture."
-msgstr ""
-"提供 Hibernate 所有运行时体系结构的更多细节不是本文档的范畴。由于 Hibernate "
-"非常灵活，且支持多种应用方案， 所以我们这只描述一下两种极端的情况：“最"
-"小”和“全面解决”的体系结构方案。"
+msgid "We do not have the scope in this document to provide a more detailed view of all the runtime architectures available; Hibernate is flexible and supports several different approaches. We will, however, show the two extremes: \"minimal\" architecture and \"comprehensive\" architecture."
+msgstr "提供 Hibernate 所有运行时体系结构的更多细节不是本文档的范畴。由于 Hibernate 非常灵活，且支持多种应用方案， 所以我们这只描述一下两种极端的情况：“最小”和“全面解决”的体系结构方案。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This next diagram illustrates how Hibernate utilizes database and "
-"configuration data to provide persistence services, and persistent objects, "
-"to the application."
-msgstr ""
-"下图演示了 Hibernate 如何使用数据库和配置信息来为应用程序提供持久化服务（以及"
-"持久的对象）。"
+msgid "This next diagram illustrates how Hibernate utilizes database and configuration data to provide persistence services, and persistent objects, to the application."
+msgstr "下图演示了 Hibernate 如何使用数据库和配置信息来为应用程序提供持久化服务（以及持久的对象）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The \"minimal\" architecture has the application provide its own JDBC "
-"connections and manage its own transactions. This approach uses a minimal "
-"subset of Hibernate's APIs:"
-msgstr ""
-"“最小”的体系结构方案，要求应用程序提供自己的 JDBC 连接并管理自己的事务。这种"
-"方案使用了Hibernate API 的最小子集："
+msgid "The \"minimal\" architecture has the application provide its own JDBC connections and manage its own transactions. This approach uses a minimal subset of Hibernate's APIs:"
+msgstr "“最小”的体系结构方案，要求应用程序提供自己的 JDBC 连接并管理自己的事务。这种方案使用了Hibernate API 的最小子集："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The \"comprehensive\" architecture abstracts the application away from the "
-"underlying JDBC/JTA APIs and allows Hibernate to manage the details."
-msgstr ""
-"“全面解决”的体系结构方案，将应用层从底层的 JDBC/JTA API 中抽象出来，而让 "
-"Hibernate 来处理这些细节。"
+msgid "The \"comprehensive\" architecture abstracts the application away from the underlying JDBC/JTA APIs and allows Hibernate to manage the details."
+msgstr "“全面解决”的体系结构方案，将应用层从底层的 JDBC/JTA API 中抽象出来，而让 Hibernate 来处理这些细节。"
 
 #. Tag: para
 #, no-c-format
@@ -83,17 +61,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A threadsafe, immutable cache of compiled mappings for a single database. A "
-"factory for <literal>Session</literal> and a client of "
-"<literal>ConnectionProvider</literal>, <literal>SessionFactory</literal> can "
-"hold an optional (second-level) cache of data that is reusable between "
-"transactions at a process, or cluster, level."
-msgstr ""
-"é’ˆå¯¹å•ä¸ªæ•°æ®åº“æ˜ å°„å…³ç³»ç»è¿‡ç¼–è¯‘åŽçš„å†…å­˜é•œåƒï¼Œæ˜¯çº¿ç¨‹å®‰å…¨çš„ï¼ˆä¸å¯å˜ï¼‰ã€‚ 作为 "
-"<literal>Session</literal> 的工厂和 <literal>ConnectionProvider</literal> 的"
-"客户。<literal>SessionFactory</literal> 可以在进程或集群的级别上，为那些事务"
-"之间可以重用的数据提供可选的二级缓存。"
+msgid "A threadsafe, immutable cache of compiled mappings for a single database. A factory for <literal>Session</literal> and a client of <literal>ConnectionProvider</literal>, <literal>SessionFactory</literal> can hold an optional (second-level) cache of data that is reusable between transactions at a process, or cluster, level."
+msgstr "é’ˆå¯¹å•ä¸ªæ•°æ®åº“æ˜ å°„å…³ç³»ç»è¿‡ç¼–è¯‘åŽçš„å†…å­˜é•œåƒï¼Œæ˜¯çº¿ç¨‹å®‰å…¨çš„ï¼ˆä¸å¯å˜ï¼‰ã€‚ 作为 <literal>Session</literal> 的工厂和 <literal>ConnectionProvider</literal> 的客户。<literal>SessionFactory</literal> 可以在进程或集群的级别上，为那些事务之间可以重用的数据提供可选的二级缓存。"
 
 #. Tag: term
 #, no-c-format
@@ -102,17 +71,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A single-threaded, short-lived object representing a conversation between "
-"the application and the persistent store. It wraps a JDBC connection and is "
-"a factory for <literal>Transaction</literal>. <literal>Session</literal> "
-"holds a mandatory first-level cache of persistent objects that are used when "
-"navigating the object graph or looking up objects by identifier."
-msgstr ""
-"表示应用程序与持久储存层之间交互操作的一个单线程对象，此对象生存期很短。其隐"
-"藏了 JDBC 连接，也是 <literal>Transaction</literal> 的工厂。它会持有一个针对"
-"æŒä¹…åŒ–å¯¹è±¡çš„å¿…é€‰ï¼ˆç¬¬ä¸€çº§ï¼‰ç¼“å­˜ï¼Œåœ¨éåŽ†å¯¹è±¡å›¾æˆ–è€…æ ¹æ®æŒä¹…åŒ–æ ‡è¯†æŸ¥æ‰¾å¯¹è±¡æ—¶ä¼šç”¨"
-"到。"
+msgid "A single-threaded, short-lived object representing a conversation between the application and the persistent store. It wraps a JDBC connection and is a factory for <literal>Transaction</literal>. <literal>Session</literal> holds a mandatory first-level cache of persistent objects that are used when navigating the object graph or looking up objects by identifier."
+msgstr "表示应用程序与持久储存层之间交互操作的一个单线程对象，此对象生存期很短。其隐藏了 JDBC 连接，也是 <literal>Transaction</literal> çš„å·¥åŽ‚ã€‚å®ƒä¼šæŒæœ‰ä¸€ä¸ªé’ˆå¯¹æŒä¹…åŒ–å¯¹è±¡çš„å¿…é€‰ï¼ˆç¬¬ä¸€çº§ï¼‰ç¼“å­˜ï¼Œåœ¨éåŽ†å¯¹è±¡å›¾æˆ–è€…æ ¹æ®æŒä¹…åŒ–æ ‡è¯†æŸ¥æ‰¾å¯¹è±¡æ—¶ä¼šç”¨åˆ°ã€‚"
 
 #. Tag: term
 #, no-c-format
@@ -121,19 +81,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Short-lived, single threaded objects containing persistent state and "
-"business function. These can be ordinary JavaBeans/POJOs. They are "
-"associated with exactly one <literal>Session</literal>. Once the "
-"<literal>Session</literal> is closed, they will be detached and free to use "
-"in any application layer (for example, directly as data transfer objects to "
-"and from presentation)."
-msgstr ""
-"带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是"
-"普通的JavaBeans/POJO，唯一特殊的是他们正与（仅仅一个）<literal>Session</"
-"literal> 相关联。一旦这个 <literal>Session</literal> 被关闭，这些对象就会脱离"
-"æŒä¹…åŒ–çŠ¶æ€ï¼Œè¿™æ ·å°±å¯è¢«åº”ç”¨ç¨‹åºçš„ä»»ä½•å±‚è‡ªç”±ä½¿ç”¨ï¼ˆä¾‹å¦‚ï¼Œç”¨ä½œè·Ÿè¡¨ç¤ºå±‚æ‰“äº¤é“çš„æ•°"
-"æ®ä¼ è¾“å¯¹è±¡ï¼‰ã€‚"
+msgid "Short-lived, single threaded objects containing persistent state and business function. These can be ordinary JavaBeans/POJOs. They are associated with exactly one <literal>Session</literal>. Once the <literal>Session</literal> is closed, they will be detached and free to use in any application layer (for example, directly as data transfer objects to and from presentation)."
+msgstr "带有持久化状态的、具有业务功能的单线程对象，此对象生存期很短。这些对象可能是普通的JavaBeans/POJO，唯一特殊的是他们正与（仅仅一个）<literal>Session</literal> 相关联。一旦这个 <literal>Session</literal> è¢«å…³é—­ï¼Œè¿™äº›å¯¹è±¡å°±ä¼šè„±ç¦»æŒä¹…åŒ–çŠ¶æ€ï¼Œè¿™æ ·å°±å¯è¢«åº”ç”¨ç¨‹åºçš„ä»»ä½•å±‚è‡ªç”±ä½¿ç”¨ï¼ˆä¾‹å¦‚ï¼Œç”¨ä½œè·Ÿè¡¨ç¤ºå±‚æ‰“äº¤é“çš„æ•°æ®ä¼ è¾“å¯¹è±¡ï¼‰ã€‚"
 
 #. Tag: term
 #, no-c-format
@@ -142,15 +91,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Instances of persistent classes that are not currently associated with a "
-"<literal>Session</literal>. They may have been instantiated by the "
-"application and not yet persisted, or they may have been instantiated by a "
-"closed <literal>Session</literal>."
-msgstr ""
-"那些目前没有与 <literal>Session</literal>关联的持久化类实例。他们可能是在被应"
-"ç”¨ç¨‹åºå®žä¾‹åŒ–åŽï¼Œå°šæœªè¿›è¡ŒæŒä¹…åŒ–çš„å¯¹è±¡ã€‚ä¹Ÿå¯èƒ½æ˜¯å› ä¸ºå®žä¾‹åŒ–ä»–ä»¬çš„ "
-"<literal>Session</literal> 已经被关闭而脱离持久化的对象。"
+msgid "Instances of persistent classes that are not currently associated with a <literal>Session</literal>. They may have been instantiated by the application and not yet persisted, or they may have been instantiated by a closed <literal>Session</literal>."
+msgstr "那些目前没有与 <literal>Session</literal>å…³è”çš„æŒä¹…åŒ–ç±»å®žä¾‹ã€‚ä»–ä»¬å¯èƒ½æ˜¯åœ¨è¢«åº”ç”¨ç¨‹åºå®žä¾‹åŒ–åŽï¼Œå°šæœªè¿›è¡ŒæŒä¹…åŒ–çš„å¯¹è±¡ã€‚ä¹Ÿå¯èƒ½æ˜¯å› ä¸ºå®žä¾‹åŒ–ä»–ä»¬çš„ <literal>Session</literal> 已经被关闭而脱离持久化的对象。"
 
 #. Tag: term
 #, no-c-format
@@ -159,84 +101,43 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"(Optional) A single-threaded, short-lived object used by the application to "
-"specify atomic units of work. It abstracts the application from the "
-"underlying JDBC, JTA or CORBA transaction. A <literal>Session</literal> "
-"might span several <literal>Transaction</literal>s in some cases. However, "
-"transaction demarcation, either using the underlying API or "
-"<literal>Transaction</literal>, is never optional."
-msgstr ""
-"（可选的）应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很"
-"短。它通过抽象将应用从底层具体的 JDBC、JTA 以及 CORBA 事务隔离开。某些情况"
-"下，一个 <literal>Session</literal> 之内可能包含多个 <literal>Transaction</"
-"literal> å¯¹è±¡ã€‚å°½ç®¡æ˜¯å¦ä½¿ç”¨è¯¥å¯¹è±¡æ˜¯å¯é€‰çš„ï¼Œä½†æ— è®ºæ˜¯ä½¿ç”¨åº•å±‚çš„ API 还是使用 "
-"<literal>Transaction</literal> 对象，事务边界的开启与关闭是必需的。 "
+msgid "(Optional) A single-threaded, short-lived object used by the application to specify atomic units of work. It abstracts the application from the underlying JDBC, JTA or CORBA transaction. A <literal>Session</literal> might span several <literal>Transaction</literal>s in some cases. However, transaction demarcation, either using the underlying API or <literal>Transaction</literal>, is never optional."
+msgstr "（可选的）应用程序用来指定原子操作单元范围的对象，它是单线程的，生命周期很短。它通过抽象将应用从底层具体的 JDBC、JTA 以及 CORBA 事务隔离开。某些情况下，一个 <literal>Session</literal> 之内可能包含多个 <literal>Transaction</literal> å¯¹è±¡ã€‚å°½ç®¡æ˜¯å¦ä½¿ç”¨è¯¥å¯¹è±¡æ˜¯å¯é€‰çš„ï¼Œä½†æ— è®ºæ˜¯ä½¿ç”¨åº•å±‚çš„ API 还是使用 <literal>Transaction</literal> 对象，事务边界的开启与关闭是必需的。 "
 
 #. Tag: term
 #, no-c-format
-msgid ""
-"ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</"
-"literal>)"
-msgstr ""
-"ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</"
-"literal>)"
+msgid "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
+msgstr "ConnectionProvider (<literal>org.hibernate.connection.ConnectionProvider</literal>)"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"(Optional) A factory for, and pool of, JDBC connections. It abstracts the "
-"application from underlying <literal>Datasource</literal> or "
-"<literal>DriverManager</literal>. It is not exposed to application, but it "
-"can be extended and/or implemented by the developer."
-msgstr ""
-"（可选的）生成 JDBC è¿žæŽ¥çš„å·¥åŽ‚ï¼ˆåŒæ—¶ä¹Ÿèµ·åˆ°è¿žæŽ¥æ± çš„ä½œç”¨ï¼‰ã€‚å®ƒé€šè¿‡æŠ½è±¡å°†åº”ç”¨ä»Ž"
-"底层的 <literal>Datasource</literal> 或 <literal>DriverManager</literal> 隔离"
-"开。仅供开发者扩展/实现用，并不开放给应用程序使用。"
+msgid "(Optional) A factory for, and pool of, JDBC connections. It abstracts the application from underlying <literal>Datasource</literal> or <literal>DriverManager</literal>. It is not exposed to application, but it can be extended and/or implemented by the developer."
+msgstr "（可选的）生成 JDBC è¿žæŽ¥çš„å·¥åŽ‚ï¼ˆåŒæ—¶ä¹Ÿèµ·åˆ°è¿žæŽ¥æ± çš„ä½œç”¨ï¼‰ã€‚å®ƒé€šè¿‡æŠ½è±¡å°†åº”ç”¨ä»Žåº•å±‚çš„ <literal>Datasource</literal> 或 <literal>DriverManager</literal> 隔离开。仅供开发者扩展/实现用，并不开放给应用程序使用。"
 
 #. Tag: term
 #, no-c-format
-msgid ""
-"TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
-msgstr ""
-"TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgid "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
+msgstr "TransactionFactory (<literal>org.hibernate.TransactionFactory</literal>)"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"(Optional) A factory for <literal>Transaction</literal> instances. It is not "
-"exposed to the application, but it can be extended and/or implemented by the "
-"developer."
-msgstr ""
-"（可选的）生成 <literal>Transaction</literal> 对象实例的工厂。仅供开发者扩展/"
-"实现用，并不开发能够给应用程序使用。"
+msgid "(Optional) A factory for <literal>Transaction</literal> instances. It is not exposed to the application, but it can be extended and/or implemented by the developer."
+msgstr "（可选的）生成 <literal>Transaction</literal> 对象实例的工厂。仅供开发者扩展/实现用，并不开发能够给应用程序使用。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<emphasis>Extension Interfaces</emphasis>"
-msgstr "扩展接口"
+msgstr "<emphasis>扩展接口</emphasis>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate offers a range of optional extension interfaces you can implement "
-"to customize the behavior of your persistence layer. See the API "
-"documentation for details."
-msgstr ""
-"Hibernate æä¾›äº†å¾ˆå¤šå¯é€‰çš„æ‰©å±•æŽ¥å£ï¼Œä½ å¯ä»¥é€šè¿‡å®žçŽ°å®ƒä»¬æ¥å®šåˆ¶ä½ çš„æŒä¹…å±‚çš„è¡Œ"
-"为。具体请参考 API 文档。"
+msgid "Hibernate offers a range of optional extension interfaces you can implement to customize the behavior of your persistence layer. See the API documentation for details."
+msgstr "Hibernate æä¾›äº†å¾ˆå¤šå¯é€‰çš„æ‰©å±•æŽ¥å£ï¼Œä½ å¯ä»¥é€šè¿‡å®žçŽ°å®ƒä»¬æ¥å®šåˆ¶ä½ çš„æŒä¹…å±‚çš„è¡Œä¸ºã€‚å…·ä½“è¯·å‚è€ƒ API 文档。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Given a \"minimal\" architecture, the application bypasses the "
-"<literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or "
-"<literal>ConnectionProvider</literal> APIs to communicate with JTA or JDBC "
-"directly."
-msgstr ""
-"在特定“最小”的体系结构中，应用程序可能绕过  <literal>Transaction</literal>/"
-"<literal>TransactionFactory</literal> 以及 <literal>ConnectionProvider</"
-"literal> 等 API 直接跟 JTA 或 JDBC 打交道。"
+msgid "Given a \"minimal\" architecture, the application bypasses the <literal>Transaction</literal>/<literal>TransactionFactory</literal> and/or <literal>ConnectionProvider</literal> APIs to communicate with JTA or JDBC directly."
+msgstr "在特定“最小”的体系结构中，应用程序可能绕过  <literal>Transaction</literal>/<literal>TransactionFactory</literal> 以及 <literal>ConnectionProvider</literal> 等 API 直接跟 JTA 或 JDBC 打交道。"
 
 #. Tag: title
 #, no-c-format
@@ -245,16 +146,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An instance of a persistent class can be in one of three different states. "
-"These states are defined in relation to a <emphasis>persistence context</"
-"emphasis>. The Hibernate <literal>Session</literal> object is the "
-"persistence context. The three different states are as follows:"
-msgstr ""
-"一个持久化类的实例可能处于三种不同状态中的某一种。这三种状态的定义则与所谓的"
-"<emphasis>持久化上下文（persistence context）</emphasis>有关。Hibernate 的 "
-"<literal>Session</literal> 对象就是这个所谓的持久化上下文。这三种不同的状态如"
-"下："
+msgid "An instance of a persistent class can be in one of three different states. These states are defined in relation to a <emphasis>persistence context</emphasis>. The Hibernate <literal>Session</literal> object is the persistence context. The three different states are as follows:"
+msgstr "一个持久化类的实例可能处于三种不同状态中的某一种。这三种状态的定义则与所谓的<emphasis>持久化上下文（persistence context）</emphasis>有关。Hibernate 的 <literal>Session</literal> 对象就是这个所谓的持久化上下文。这三种不同的状态如下："
 
 #. Tag: term
 #, no-c-format
@@ -263,11 +156,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The instance is not associated with any persistence context. It has no "
-"persistent identity or primary key value."
-msgstr ""
-"è¯¥å®žä¾‹ä»Žæœªä¸Žä»»ä½•æŒä¹…åŒ–ä¸Šä¸‹æ–‡å…³è”è¿‡ã€‚å®ƒæ²¡æœ‰æŒä¹…åŒ–æ ‡è¯†ï¼ˆç›¸å½“äºŽä¸»é”®å€¼ï¼‰ã€‚ "
+msgid "The instance is not associated with any persistence context. It has no persistent identity or primary key value."
+msgstr "è¯¥å®žä¾‹ä»Žæœªä¸Žä»»ä½•æŒä¹…åŒ–ä¸Šä¸‹æ–‡å…³è”è¿‡ã€‚å®ƒæ²¡æœ‰æŒä¹…åŒ–æ ‡è¯†ï¼ˆç›¸å½“äºŽä¸»é”®å€¼ï¼‰ã€‚ "
 
 #. Tag: term
 #, no-c-format
@@ -276,16 +166,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The instance is currently associated with a persistence context. It has a "
-"persistent identity (primary key value) and can have a corresponding row in "
-"the database. For a particular persistence context, Hibernate "
-"<emphasis>guarantees</emphasis> that persistent identity is equivalent to "
-"Java identity in relation to the in-memory location of the object."
-msgstr ""
-"å®žä¾‹ç›®å‰ä¸ŽæŸä¸ªæŒä¹…åŒ–ä¸Šä¸‹æ–‡æœ‰å…³è”ã€‚å®ƒæ‹¥æœ‰æŒä¹…åŒ–æ ‡è¯†ï¼ˆç›¸å½“äºŽä¸»é”®å€¼ï¼‰ï¼Œå¹¶ä¸”å¯èƒ½"
-"在数据库中有一个对应的行。对于某一个特定的持久化上下文，Hibernate <emphasis>"
-"保证</emphasis> æŒä¹…åŒ–æ ‡è¯†ä¸Ž Java æ ‡è¯†ï¼ˆå…¶å€¼ä»£è¡¨å¯¹è±¡åœ¨å†…å­˜ä¸­çš„ä½ç½®ï¼‰ç­‰ä»·ã€‚ã€€"
+msgid "The instance is currently associated with a persistence context. It has a persistent identity (primary key value) and can have a corresponding row in the database. For a particular persistence context, Hibernate <emphasis>guarantees</emphasis> that persistent identity is equivalent to Java identity in relation to the in-memory location of the object."
+msgstr "å®žä¾‹ç›®å‰ä¸ŽæŸä¸ªæŒä¹…åŒ–ä¸Šä¸‹æ–‡æœ‰å…³è”ã€‚å®ƒæ‹¥æœ‰æŒä¹…åŒ–æ ‡è¯†ï¼ˆç›¸å½“äºŽä¸»é”®å€¼ï¼‰ï¼Œå¹¶ä¸”å¯èƒ½åœ¨æ•°æ®åº“ä¸­æœ‰ä¸€ä¸ªå¯¹åº”çš„è¡Œã€‚å¯¹äºŽæŸä¸€ä¸ªç‰¹å®šçš„æŒä¹…åŒ–ä¸Šä¸‹æ–‡ï¼ŒHibernate <emphasis>保证</emphasis> æŒä¹…åŒ–æ ‡è¯†ä¸Ž Java æ ‡è¯†ï¼ˆå…¶å€¼ä»£è¡¨å¯¹è±¡åœ¨å†…å­˜ä¸­çš„ä½ç½®ï¼‰ç­‰ä»·ã€‚ã€€"
 
 #. Tag: term
 #, no-c-format
@@ -294,17 +176,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The instance was once associated with a persistence context, but that "
-"context was closed, or the instance was serialized to another process. It "
-"has a persistent identity and can have a corresponding row in the database. "
-"For detached instances, Hibernate does not guarantee the relationship "
-"between persistent identity and Java identity."
-msgstr ""
-"实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了，或者这个实例是"
-"被序列化（serializeï¼‰åˆ°å¦å¤–çš„è¿›ç¨‹ã€‚å®ƒæ‹¥æœ‰æŒä¹…åŒ–æ ‡è¯†ï¼Œå¹¶ä¸”åœ¨æ•°æ®åº“ä¸­å¯èƒ½å­˜åœ¨ä¸€"
-"个对应的行。对于脱管状态的实例，Hibernate ä¸ä¿è¯ä»»ä½•æŒä¹…åŒ–æ ‡è¯†å’Œ Java æ ‡è¯†çš„"
-"关系。 "
+msgid "The instance was once associated with a persistence context, but that context was closed, or the instance was serialized to another process. It has a persistent identity and can have a corresponding row in the database. For detached instances, Hibernate does not guarantee the relationship between persistent identity and Java identity."
+msgstr "实例曾经与某个持久化上下文发生过关联，不过那个上下文被关闭了，或者这个实例是被序列化（serializeï¼‰åˆ°å¦å¤–çš„è¿›ç¨‹ã€‚å®ƒæ‹¥æœ‰æŒä¹…åŒ–æ ‡è¯†ï¼Œå¹¶ä¸”åœ¨æ•°æ®åº“ä¸­å¯èƒ½å­˜åœ¨ä¸€ä¸ªå¯¹åº”çš„è¡Œã€‚å¯¹äºŽè„±ç®¡çŠ¶æ€çš„å®žä¾‹ï¼ŒHibernate ä¸ä¿è¯ä»»ä½•æŒä¹…åŒ–æ ‡è¯†å’Œ Java æ ‡è¯†çš„å…³ç³»ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -313,79 +186,33 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"JMX is the J2EE standard for the management of Java components. Hibernate "
-"can be managed via a JMX standard service. AN MBean implementation is "
-"provided in the distribution: <literal>org.hibernate.jmx.HibernateService</"
-"literal>."
-msgstr ""
-"JMX 是管理 Java 组件的 J2EE æ ‡å‡†ã€‚Hibernate 可以通过一个 JMX æ ‡å‡†æœåŠ¡æ¥ç®¡ç†ã€‚"
-"在这个发行版本中，我们提供了一个 MBean 接口的实现,即 <literal>org.hibernate."
-"jmx.HibernateService</literal>。 "
+msgid "JMX is the J2EE standard for the management of Java components. Hibernate can be managed via a JMX standard service. AN MBean implementation is provided in the distribution: <literal>org.hibernate.jmx.HibernateService</literal>."
+msgstr "JMX 是管理 Java 组件的 J2EE æ ‡å‡†ã€‚Hibernate 可以通过一个 JMX æ ‡å‡†æœåŠ¡æ¥ç®¡ç†ã€‚åœ¨è¿™ä¸ªå‘è¡Œç‰ˆæœ¬ä¸­ï¼Œæˆ‘ä»¬æä¾›äº†ä¸€ä¸ª MBean 接口的实现,即 <literal>org.hibernate.jmx.HibernateService</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For an example of how to deploy Hibernate as a JMX service on the JBoss "
-"Application Server, please see the JBoss User Guide. JBoss AS also provides "
-"these benefits if you deploy using JMX:"
-msgstr ""
-"想要看如何在 JBoss 应用服务器上将 Hibernate 部署为一个 JMX 服务的例子，您可以"
-"参考《JBoss ç”¨æˆ·æŒ‡å—ã€‹ã€‚å¦‚æžœä½ ä½¿ç”¨ JMX 来部署 Hibernate，JBoss AS 也提供如下"
-"好处："
+msgid "For an example of how to deploy Hibernate as a JMX service on the JBoss Application Server, please see the JBoss User Guide. JBoss AS also provides these benefits if you deploy using JMX:"
+msgstr "想要看如何在 JBoss 应用服务器上将 Hibernate 部署为一个 JMX 服务的例子，您可以参考《JBoss ç”¨æˆ·æŒ‡å—ã€‹ã€‚å¦‚æžœä½ ä½¿ç”¨ JMX 来部署 Hibernate，JBoss AS 也提供如下好处："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Session Management</emphasis>: the Hibernate <literal>Session</"
-"literal>'s life cycle can be automatically bound to the scope of a JTA "
-"transaction. This means that you no longer have to manually open and close "
-"the <literal>Session</literal>; this becomes the job of a JBoss EJB "
-"interceptor. You also do not have to worry about transaction demarcation in "
-"your code (if you would like to write a portable persistence layer use the "
-"optional Hibernate <literal>Transaction</literal> API for this). You call "
-"the <literal>HibernateContext</literal> to access a <literal>Session</"
-"literal>."
-msgstr ""
-"<emphasis>会话管理：</emphasis> Hibernate 的 <literal>Session</literal> 对象"
-"的生命周期可以 自动跟一个 JTA äº‹åŠ¡è¾¹ç•Œç»‘å®šã€‚è¿™æ„å‘³ç€ä½ æ— éœ€æ‰‹å·¥å¼€å…³ "
-"<literal>Session</literal> 了, 这项工作会由 JBoss EJB æ‹¦æˆªå™¨æ¥å®Œæˆã€‚ä½ å†ä¹Ÿä¸"
-"ç”¨æ‹…å¿ƒä½ çš„ä»£ç ä¸­çš„äº‹åŠ¡è¾¹ç•Œäº†ï¼ˆé™¤éžä½ æƒ³åˆ©ç”¨ Hibernate 提供可选的 "
-"<literal>Transaction</literal> API æ¥è‡ªå·±å†™ä¸€ä¸ªä¾¿äºŽç§»æ¤çš„çš„æŒä¹…å±‚ï¼‰ã€‚ä½ é€šè¿‡è°ƒ"
-"用 <literal>HibernateContext</literal> 来访问 <literal>Session</literal>。"
+msgid "<emphasis>Session Management</emphasis>: the Hibernate <literal>Session</literal>'s life cycle can be automatically bound to the scope of a JTA transaction. This means that you no longer have to manually open and close the <literal>Session</literal>; this becomes the job of a JBoss EJB interceptor. You also do not have to worry about transaction demarcation in your code (if you would like to write a portable persistence layer use the optional Hibernate <literal>Transaction</literal> API for this). You call the <literal>HibernateContext</literal> to access a <literal>Session</literal>."
+msgstr "<emphasis>会话管理：</emphasis> Hibernate çš„ <literal>Session</literal> 对象的生命周期可以 自动跟一个 JTA äº‹åŠ¡è¾¹ç•Œç»‘å®šã€‚è¿™æ„å‘³ç€ä½ æ— éœ€æ‰‹å·¥å¼€å…³ <literal>Session</literal> 了, 这项工作会由 JBoss EJB æ‹¦æˆªå™¨æ¥å®Œæˆã€‚ä½ å†ä¹Ÿä¸ç”¨æ‹…å¿ƒä½ çš„ä»£ç ä¸­çš„äº‹åŠ¡è¾¹ç•Œäº†ï¼ˆé™¤éžä½ æƒ³åˆ©ç”¨ Hibernate 提供可选的 <literal>Transaction</literal> API æ¥è‡ªå·±å†™ä¸€ä¸ªä¾¿äºŽç§»æ¤çš„çš„æŒä¹…å±‚ï¼‰ã€‚ä½ é€šè¿‡è°ƒç”¨ <literal>HibernateContext</literal> 来访问 <literal>Session</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>HAR deployment</emphasis>: the Hibernate JMX service is deployed "
-"using a JBoss service deployment descriptor in an EAR and/or SAR file, as it "
-"supports all the usual configuration options of a Hibernate "
-"<literal>SessionFactory</literal>. However, you still need to name all your "
-"mapping files in the deployment descriptor. If you use the optional HAR "
-"deployment, JBoss will automatically detect all mapping files in your HAR "
-"file."
-msgstr ""
-"<emphasis>HAR 部署:</emphasis> é€šå¸¸æƒ…å†µä¸‹ï¼Œä½ ä¼šä½¿ç”¨ JBoss 的服务部署描述符"
-"（在 EAR 或/和 SAR 文件中）来部署 Hibernate JMX 服务。这种部署方式支持所有常"
-"见的 Hibernate <literal>SessionFactory</literal> çš„é…ç½®é€‰é¡¹ã€‚ä¸è¿‡ï¼Œä½ ä»éœ€åœ¨éƒ¨"
-"ç½²æè¿°ç¬¦ä¸­ï¼Œåˆ—å‡ºä½ æ‰€æœ‰çš„æ˜ å°„æ–‡çš„åå­—ã€‚å¦‚æžœä½ ä½¿ç”¨ HAR 部署方式, JBoss 会自动探"
-"æµ‹å‡ºä½ çš„ HAR æ–‡ä»¶ä¸­æ‰€æœ‰çš„æ˜ å°„æ–‡ä»¶ã€‚"
+msgid "<emphasis>HAR deployment</emphasis>: the Hibernate JMX service is deployed using a JBoss service deployment descriptor in an EAR and/or SAR file, as it supports all the usual configuration options of a Hibernate <literal>SessionFactory</literal>. However, you still need to name all your mapping files in the deployment descriptor. If you use the optional HAR deployment, JBoss will automatically detect all mapping files in your HAR file."
+msgstr "<emphasis>HAR 部署:</emphasis> é€šå¸¸æƒ…å†µä¸‹ï¼Œä½ ä¼šä½¿ç”¨ JBoss 的服务部署描述符（在 EAR 或/å’Œ SAR 文件中）来部署 Hibernate JMX 服务。这种部署方式支持所有常见的 Hibernate <literal>SessionFactory</literal> çš„é…ç½®é€‰é¡¹ã€‚ä¸è¿‡ï¼Œä½ ä»éœ€åœ¨éƒ¨ç½²æè¿°ç¬¦ä¸­ï¼Œåˆ—å‡ºä½ æ‰€æœ‰çš„æ˜ å°„æ–‡çš„åå­—ã€‚å¦‚æžœä½ ä½¿ç”¨ HAR 部署方式, JBoss ä¼šè‡ªåŠ¨æŽ¢æµ‹å‡ºä½ çš„ HAR æ–‡ä»¶ä¸­æ‰€æœ‰çš„æ˜ å°„æ–‡ä»¶ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Consult the JBoss AS user guide for more information about these options."
+msgid "Consult the JBoss AS user guide for more information about these options."
 msgstr "这些选项更多的描述，请参考 JBoss 应用程序用户指南。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Another feature available as a JMX service is runtime Hibernate statistics. "
-"See <xref linkend=\"configuration-optional-statistics\" /> for more "
-"information."
-msgstr ""
-"将 Hibernate 以部署为 JMX 服务的另一个好处，是可以查看 Hibernate 的运行时统计"
-"信息。参看 <xref linkend=\"configuration-optional-statistics\"/>。"
+#, no-c-format
+msgid "Another feature available as a JMX service is runtime Hibernate statistics. See <xref linkend=\"configuration-optional-statistics\" /> for more information."
+msgstr "将 Hibernate 以部署为 JMX 服务的另一个好处，是可以查看 Hibernate 的运行时统计信息。参看 <xref linkend=\"configuration-optional-statistics\"/>。 "
 
 #. Tag: title
 #, no-c-format
@@ -394,13 +221,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate can also be configured as a JCA connector. Please see the website "
-"for more information. Please note, however, that at this stage Hibernate JCA "
-"support is under development."
-msgstr ""
-"Hibernate 也可以被配置为一个 JCA 连接器（JCA connector）。更多信息请参看网"
-"站。请注意，Hibernate 对 JCA 的支持，仍处于实验性阶段。"
+msgid "Hibernate can also be configured as a JCA connector. Please see the website for more information. Please note, however, that at this stage Hibernate JCA support is under development."
+msgstr "Hibernate 也可以被配置为一个 JCA 连接器（JCA connector）。更多信息请参看网站。请注意，Hibernate 对 JCA 的支持，仍处于实验性阶段。"
 
 #. Tag: title
 #, no-c-format
@@ -409,155 +231,46 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Most applications using Hibernate need some form of \"contextual\" session, "
-"where a given session is in effect throughout the scope of a given context. "
-"However, across applications the definition of what constitutes a context is "
-"typically different; different contexts define different scopes to the "
-"notion of current. Applications using Hibernate prior to version 3.0 tended "
-"to utilize either home-grown <literal>ThreadLocal</literal>-based contextual "
-"sessions, helper classes such as <literal>HibernateUtil</literal>, or "
-"utilized third-party frameworks, such as Spring or Pico, which provided "
-"proxy/interception-based contextual sessions."
-msgstr ""
-"使用 Hibernate 的大多数应用程序需要某种形式的“上下文相关的”会话，特定的会话在"
-"整个特定的上下文范围内始终有效。然而，对不同类型的应用程序而言，要为什么是组"
-"成这种“上下文”下一个定义通常是困难的；不同的上下文对“当前”这个概念定义了不同"
-"的范围。在 3.0 版本之前，使用 Hibernate 的程序要么采用自行编写的基于 "
-"<literal>ThreadLocal</literal> 的上下文会话，要么采用 "
-"<literal>HibernateUtil</literal> è¿™æ ·çš„è¾…åŠ©ç±»ï¼Œè¦ä¹ˆé‡‡ç”¨ç¬¬ä¸‰æ–¹æ¡†æž¶ï¼ˆæ¯”å¦‚ "
-"Spring 或 Pico），它们提供了基于代理（proxy）或者基于拦截器（interception）的"
-"上下文相关的会话。"
+msgid "Most applications using Hibernate need some form of \"contextual\" session, where a given session is in effect throughout the scope of a given context. However, across applications the definition of what constitutes a context is typically different; different contexts define different scopes to the notion of current. Applications using Hibernate prior to version 3.0 tended to utilize either home-grown <literal>ThreadLocal</literal>-based contextual sessions, helper classes such as <literal>HibernateUtil</literal>, or utilized third-party frameworks, such as Spring or Pico, which provided proxy/interception-based contextual sessions."
+msgstr "使用 Hibernate 的大多数应用程序需要某种形式的“上下文相关的”会话，特定的会话在整个特定的上下文范围内始终有效。然而，对不同类型的应用程序而言，要为什么是组成这种“上下文”下一个定义通常是困难的；不同的上下文对“当前”这个概念定义了不同的范围。在 3.0 版本之前，使用 Hibernate 的程序要么采用自行编写的基于 <literal>ThreadLocal</literal> 的上下文会话，要么采用 <literal>HibernateUtil</literal> è¿™æ ·çš„è¾…åŠ©ç±»ï¼Œè¦ä¹ˆé‡‡ç”¨ç¬¬ä¸‰æ–¹æ¡†æž¶ï¼ˆæ¯”å¦‚ Spring 或 Pico），它们提供了基于代理（proxy）或者基于拦截器（interception）的上下文相关的会话。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Starting with version 3.0.1, Hibernate added the <literal>SessionFactory."
-"getCurrentSession()</literal> method. Initially, this assumed usage of "
-"<literal>JTA</literal> transactions, where the <literal>JTA</literal> "
-"transaction defined both the scope and context of a current session. Given "
-"the maturity of the numerous stand-alone <literal>JTA TransactionManager</"
-"literal> implementations, most, if not all, applications should be using "
-"<literal>JTA</literal> transaction management, whether or not they are "
-"deployed into a <literal>J2EE</literal> container. Based on that, the "
-"<literal>JTA</literal>-based contextual sessions are all you need to use."
-msgstr ""
-"从 3.0.1 版本开始，Hibernate å¢žåŠ äº† <literal>SessionFactory.getCurrentSession"
-"()</literal> 方法。一开始，它假定了采用 <literal>JTA</literal> 事务，"
-"<literal>JTA</literal> 事务定义了当前 session 的范围和上下文（scope 和 "
-"contextï¼‰ã€‚å› ä¸ºæœ‰å¥½å‡ ä¸ªç‹¬ç«‹çš„ <literal>JTA TransactionManager</literal> 实现"
-"稳定可用，不论是否被部署到一个 <literal>J2EE</literal> 容器中，大多数（假若不"
-"是所有的）应用程序都应该采用 <literal>JTA</literal> 事务管理。基于这一点，采"
-"用 <literal>JTA</literal> çš„ä¸Šä¸‹æ–‡ç›¸å…³çš„ä¼šè¯å¯ä»¥æ»¡è¶³ä½ ä¸€åˆ‡éœ€è¦ã€‚"
+msgid "Starting with version 3.0.1, Hibernate added the <literal>SessionFactory.getCurrentSession()</literal> method. Initially, this assumed usage of <literal>JTA</literal> transactions, where the <literal>JTA</literal> transaction defined both the scope and context of a current session. Given the maturity of the numerous stand-alone <literal>JTA TransactionManager</literal> implementations, most, if not all, applications should be using <literal>JTA</literal> transaction management, whether or not they are deployed into a <literal>J2EE</literal> container. Based on that, the <literal>JTA</literal>-based contextual sessions are all you need to use."
+msgstr "从 3.0.1 版本开始，Hibernate å¢žåŠ äº† <literal>SessionFactory.getCurrentSession()</literal> 方法。一开始，它假定了采用 <literal>JTA</literal> 事务，<literal>JTA</literal> 事务定义了当前 session 的范围和上下文（scope å’Œ contextï¼‰ã€‚å› ä¸ºæœ‰å¥½å‡ ä¸ªç‹¬ç«‹çš„ <literal>JTA TransactionManager</literal> 实现稳定可用，不论是否被部署到一个 <literal>J2EE</literal> 容器中，大多数（假若不是所有的）应用程序都应该采用 <literal>JTA</literal> 事务管理。基于这一点，采用 <literal>JTA</literal> çš„ä¸Šä¸‹æ–‡ç›¸å…³çš„ä¼šè¯å¯ä»¥æ»¡è¶³ä½ ä¸€åˆ‡éœ€è¦ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"However, as of version 3.1, the processing behind <literal>SessionFactory."
-"getCurrentSession()</literal> is now pluggable. To that end, a new extension "
-"interface, <literal>org.hibernate.context.CurrentSessionContext</literal>, "
-"and a new configuration parameter, <literal>hibernate."
-"current_session_context_class</literal>, have been added to allow "
-"pluggability of the scope and context of defining current sessions."
-msgstr ""
-"更好的是，从 3.1 开始，<literal>SessionFactory.getCurrentSession()</literal> "
-"çš„åŽå°å®žçŽ°æ˜¯å¯æ‹”æ’çš„ã€‚å› æ­¤ï¼Œæˆ‘ä»¬å¼•å…¥äº†æ–°çš„æ‰©å±•æŽ¥å£ï¼ˆ<literal>org.hibernate."
-"context.CurrentSessionContext</literal>）和新的配置参数（<literal>hibernate."
-"current_session_context_class</literal>），以便对什么是当前会话的范围"
-"（scope）和上下文（context）的定义进行拔插。"
+msgid "However, as of version 3.1, the processing behind <literal>SessionFactory.getCurrentSession()</literal> is now pluggable. To that end, a new extension interface, <literal>org.hibernate.context.CurrentSessionContext</literal>, and a new configuration parameter, <literal>hibernate.current_session_context_class</literal>, have been added to allow pluggability of the scope and context of defining current sessions."
+msgstr "更好的是，从 3.1 开始，<literal>SessionFactory.getCurrentSession()</literal> çš„åŽå°å®žçŽ°æ˜¯å¯æ‹”æ’çš„ã€‚å› æ­¤ï¼Œæˆ‘ä»¬å¼•å…¥äº†æ–°çš„æ‰©å±•æŽ¥å£ï¼ˆ<literal>org.hibernate.context.CurrentSessionContext</literal>）和新的配置参数（<literal>hibernate.current_session_context_class</literal>），以便对什么是当前会话的范围（scope）和上下文（context）的定义进行拔插。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"See the Javadocs for the <literal>org.hibernate.context."
-"CurrentSessionContext</literal> interface for a detailed discussion of its "
-"contract. It defines a single method, <literal>currentSession()</literal>, "
-"by which the implementation is responsible for tracking the current "
-"contextual session. Out-of-the-box, Hibernate comes with three "
-"implementations of this interface:"
-msgstr ""
-"请参阅 <literal>org.hibernate.context.CurrentSessionContext</literal> 接口的 "
-"Javadoc，那里有关于它的契约的详细讨论。它定义了单一的方法，"
-"<literal>currentSession()</literal>，特定的实现用它来负责跟踪当前的上下文相关"
-"的会话。Hibernate 内置了此接口的三种实现："
+msgid "See the Javadocs for the <literal>org.hibernate.context.CurrentSessionContext</literal> interface for a detailed discussion of its contract. It defines a single method, <literal>currentSession()</literal>, by which the implementation is responsible for tracking the current contextual session. Out-of-the-box, Hibernate comes with three implementations of this interface:"
+msgstr "请参阅 <literal>org.hibernate.context.CurrentSessionContext</literal> 接口的 Javadoc，那里有关于它的契约的详细讨论。它定义了单一的方法，<literal>currentSession()</literal>，特定的实现用它来负责跟踪当前的上下文相关的会话。Hibernate 内置了此接口的三种实现："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>org.hibernate.context.JTASessionContext</literal>: current sessions "
-"are tracked and scoped by a <literal>JTA</literal> transaction. The "
-"processing here is exactly the same as in the older JTA-only approach. See "
-"the Javadocs for details."
-msgstr ""
-"<literal>org.hibernate.context.JTASessionContext</literal>ï¼šå½“å‰ä¼šè¯æ ¹æ® "
-"<literal>JTA</literal> 来跟踪和界定。这和以前的仅支持 JTA çš„æ–¹æ³•æ˜¯å®Œå…¨ä¸€æ ·"
-"的。详情请参阅 Javadoc。"
+msgid "<literal>org.hibernate.context.JTASessionContext</literal>: current sessions are tracked and scoped by a <literal>JTA</literal> transaction. The processing here is exactly the same as in the older JTA-only approach. See the Javadocs for details."
+msgstr "<literal>org.hibernate.context.JTASessionContext</literal>ï¼šå½“å‰ä¼šè¯æ ¹æ® <literal>JTA</literal> 来跟踪和界定。这和以前的仅支持 JTA çš„æ–¹æ³•æ˜¯å®Œå…¨ä¸€æ ·çš„ã€‚è¯¦æƒ…è¯·å‚é˜… Javadoc。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>org.hibernate.context.ThreadLocalSessionContext</literal>:current "
-"sessions are tracked by thread of execution. See the Javadocs for details."
-msgstr ""
-"<literal>org.hibernate.context.ThreadLocalSessionContext</literal>：当前会话"
-"通过当前执行的线程来跟踪和界定。详情也请参阅 Javadoc。"
+msgid "<literal>org.hibernate.context.ThreadLocalSessionContext</literal>:current sessions are tracked by thread of execution. See the Javadocs for details."
+msgstr "<literal>org.hibernate.context.ThreadLocalSessionContext</literal>：当前会话通过当前执行的线程来跟踪和界定。详情也请参阅 Javadoc。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>org.hibernate.context.ManagedSessionContext</literal>: current "
-"sessions are tracked by thread of execution. However, you are responsible to "
-"bind and unbind a <literal>Session</literal> instance with static methods on "
-"this class: it does not open, flush, or close a <literal>Session</literal>."
-msgstr ""
-"<literal>org.hibernate.context.ManagedSessionContext</literal>：当前会话通过"
-"å½“å‰æ‰§è¡Œçš„çº¿ç¨‹æ¥è·Ÿè¸ªå’Œç•Œå®šã€‚ä½†æ˜¯ï¼Œä½ éœ€è¦è´Ÿè´£ä½¿ç”¨è¿™ä¸ªç±»çš„é™æ€æ–¹æ³•å°† "
-"<literal>Session</literal> 实例绑定、或者取消绑定，它并不会打开（open）、"
-"flush 或者关闭（close）任何 <literal>Session</literal>。"
+msgid "<literal>org.hibernate.context.ManagedSessionContext</literal>: current sessions are tracked by thread of execution. However, you are responsible to bind and unbind a <literal>Session</literal> instance with static methods on this class: it does not open, flush, or close a <literal>Session</literal>."
+msgstr "<literal>org.hibernate.context.ManagedSessionContext</literal>ï¼šå½“å‰ä¼šè¯é€šè¿‡å½“å‰æ‰§è¡Œçš„çº¿ç¨‹æ¥è·Ÿè¸ªå’Œç•Œå®šã€‚ä½†æ˜¯ï¼Œä½ éœ€è¦è´Ÿè´£ä½¿ç”¨è¿™ä¸ªç±»çš„é™æ€æ–¹æ³•å°† <literal>Session</literal> 实例绑定、或者取消绑定，它并不会打开（open）、flush 或者关闭（close）任何 <literal>Session</literal>。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The first two implementations provide a \"one session - one database "
-"transaction\" programming model. This is also also known and used as "
-"<emphasis>session-per-request</emphasis>. The beginning and end of a "
-"Hibernate session is defined by the duration of a database transaction. If "
-"you use programmatic transaction demarcation in plain JSE without JTA, you "
-"are advised to use the Hibernate <literal>Transaction</literal> API to hide "
-"the underlying transaction system from your code. If you use JTA, you can "
-"utilize the JTA interfaces to demarcate transactions. If you execute in an "
-"EJB container that supports CMT, transaction boundaries are defined "
-"declaratively and you do not need any transaction or session demarcation "
-"operations in your code. Refer to <xref linkend=\"transactions\" /> for more "
-"information and code examples."
-msgstr ""
-"前两种实现都提供了“one session - one database transaction”的编程模型，也称作 "
-"<emphasis>session-per-request</emphasis>。Hibernate session 的起始和终结由数"
-"æ®åº“äº‹åŠ¡çš„ç”Ÿå­˜æ¥æŽ§åˆ¶ã€‚å‡è‹¥ä½ åœ¨çº¯ç²¹çš„ Java SEä¹‹ä¸Šé‡‡ç”¨è‡ªè¡Œç¼–å†™ä»£ç æ¥ç®¡ç†äº‹åŠ¡ï¼Œ"
-"而不使用 JTAï¼Œå»ºè®®ä½ ä½¿ç”¨ Hibernate <literal>Transaction</literal> API 来把底"
-"å±‚äº‹åŠ¡å®žçŽ°ä»Žä½ çš„ä»£ç ä¸­éšè—æŽ‰ã€‚å¦‚æžœä½ ä½¿ç”¨ JTA，请使用 JTA 接口来对事务限界。如"
-"æžœä½ åœ¨æ”¯æŒ CMT çš„ EJB å®¹å™¨ä¸­æ‰§è¡Œä»£ç ï¼Œäº‹åŠ¡è¾¹ç•Œæ˜¯å£°æ˜Žå¼å®šä¹‰çš„ï¼Œä½ ä¸éœ€è¦åœ¨ä»£ç "
-"中进行任何事务或会话管理操作。请参阅 <xref linkend=\"transactions\"/> 一节来"
-"é˜…è¯»æ›´å¤šçš„å†…å®¹å’Œç¤ºä¾‹ä»£ç ã€‚"
+#, no-c-format
+msgid "The first two implementations provide a \"one session - one database transaction\" programming model. This is also also known and used as <emphasis>session-per-request</emphasis>. The beginning and end of a Hibernate session is defined by the duration of a database transaction. If you use programmatic transaction demarcation in plain JSE without JTA, you are advised to use the Hibernate <literal>Transaction</literal> API to hide the underlying transaction system from your code. If you use JTA, you can utilize the JTA interfaces to demarcate transactions. If you execute in an EJB container that supports CMT, transaction boundaries are defined declaratively and you do not need any transaction or session demarcation operations in your code. Refer to <xref linkend=\"transactions\" /> for more information and code examples."
+msgstr "前两种实现都提供了“one session - one database transaction”的编程模型，也称作 <emphasis>session-per-request</emphasis>。Hibernate session çš„èµ·å§‹å’Œç»ˆç»“ç”±æ•°æ®åº“äº‹åŠ¡çš„ç”Ÿå­˜æ¥æŽ§åˆ¶ã€‚å‡è‹¥ä½ åœ¨çº¯ç²¹çš„ Java SEä¹‹ä¸Šé‡‡ç”¨è‡ªè¡Œç¼–å†™ä»£ç æ¥ç®¡ç†äº‹åŠ¡ï¼Œè€Œä¸ä½¿ç”¨ JTAï¼Œå»ºè®®ä½ ä½¿ç”¨ Hibernate <literal>Transaction</literal> API æ¥æŠŠåº•å±‚äº‹åŠ¡å®žçŽ°ä»Žä½ çš„ä»£ç ä¸­éšè—æŽ‰ã€‚å¦‚æžœä½ ä½¿ç”¨ JTA，请使用 JTA æŽ¥å£æ¥å¯¹äº‹åŠ¡é™ç•Œã€‚å¦‚æžœä½ åœ¨æ”¯æŒ CMT çš„ EJB å®¹å™¨ä¸­æ‰§è¡Œä»£ç ï¼Œäº‹åŠ¡è¾¹ç•Œæ˜¯å£°æ˜Žå¼å®šä¹‰çš„ï¼Œä½ ä¸éœ€è¦åœ¨ä»£ç ä¸­è¿›è¡Œä»»ä½•äº‹åŠ¡æˆ–ä¼šè¯ç®¡ç†æ“ä½œã€‚è¯·å‚é˜… <xref linkend=\"transactions\"/> ä¸€èŠ‚æ¥é˜…è¯»æ›´å¤šçš„å†…å®¹å’Œç¤ºä¾‹ä»£ç ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>hibernate.current_session_context_class</literal> configuration "
-"parameter defines which <literal>org.hibernate.context."
-"CurrentSessionContext</literal> implementation should be used. For backwards "
-"compatibility, if this configuration parameter is not set but a <literal>org."
-"hibernate.transaction.TransactionManagerLookup</literal> is configured, "
-"Hibernate will use the <literal>org.hibernate.context.JTASessionContext</"
-"literal>. Typically, the value of this parameter would just name the "
-"implementation class to use. For the three out-of-the-box implementations, "
-"however, there are three corresponding short names: \"jta\", \"thread\", and "
-"\"managed\"."
-msgstr ""
-"<literal>hibernate.current_session_context_class</literal> 配置参数定义了应该"
-"采用哪个 <literal>org.hibernate.context.CurrentSessionContext</literal> 实"
-"现。注意，为了向下兼容，如果未配置此参数，但是存在 <literal>org.hibernate."
-"transaction.TransactionManagerLookup</literal> 的配置，Hibernate 会采用"
-"<literal>org.hibernate.context.JTASessionContext</literal>。一般而言，此参数"
-"的值指明了要使用的实现类的全名，但那三种内置的实现可以使用简写，即 \"jta\"、"
-"\"thread\" 和 \"managed\"。 "
+msgid "The <literal>hibernate.current_session_context_class</literal> configuration parameter defines which <literal>org.hibernate.context.CurrentSessionContext</literal> implementation should be used. For backwards compatibility, if this configuration parameter is not set but a <literal>org.hibernate.transaction.TransactionManagerLookup</literal> is configured, Hibernate will use the <literal>org.hibernate.context.JTASessionContext</literal>. Typically, the value of this parameter would just name the implementation class to use. For the three out-of-the-box implementations, however, there are three corresponding short names: \"jta\", \"thread\", and \"managed\"."
+msgstr "<literal>hibernate.current_session_context_class</literal> 配置参数定义了应该采用哪个 <literal>org.hibernate.context.CurrentSessionContext</literal> 实现。注意，为了向下兼容，如果未配置此参数，但是存在 <literal>org.hibernate.transaction.TransactionManagerLookup</literal> 的配置，Hibernate 会采用<literal>org.hibernate.context.JTASessionContext</literal>。一般而言，此参数的值指明了要使用的实现类的全名，但那三种内置的实现可以使用简写，即 \"jta\"、\"thread\" 和 \"managed\"。 "
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -7,7 +7,7 @@
 "Project-Id-Version: basic_mapping\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-12-03T00:15:25\n"
-"PO-Revision-Date: 2009-11-23 09:52+1000\n"
+"PO-Revision-Date: 2009-12-11 09:27+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -27,25 +27,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Object/relational mappings are usually defined in an XML document. The "
-"mapping document is designed to be readable and hand-editable. The mapping "
-"language is Java-centric, meaning that mappings are constructed around "
-"persistent class declarations and not table declarations."
-msgstr ""
-"å¯¹è±¡å’Œå…³ç³»æ•°æ®åº“ä¹‹é—´çš„æ˜ å°„é€šå¸¸æ˜¯ç”¨ä¸€ä¸ª XML æ–‡æ¡£æ¥å®šä¹‰çš„ã€‚è¿™ä¸ªæ˜ å°„æ–‡æ¡£è¢«è®¾è®¡ä¸º"
-"æ˜“è¯»çš„ï¼Œå¹¶ä¸”å¯ä»¥æ‰‹å·¥ä¿®æ”¹ã€‚æ˜ å°„è¯­è¨€æ˜¯ä»¥ Java ä¸ºä¸­å¿ƒï¼Œè¿™æ„å‘³ç€æ˜ å°„æ–‡æ¡£æ˜¯æŒ‰ç…§æŒ"
-"久化类的定义来创建的，而非表的定义。 "
+msgid "Object/relational mappings are usually defined in an XML document. The mapping document is designed to be readable and hand-editable. The mapping language is Java-centric, meaning that mappings are constructed around persistent class declarations and not table declarations."
+msgstr "å¯¹è±¡å’Œå…³ç³»æ•°æ®åº“ä¹‹é—´çš„æ˜ å°„é€šå¸¸æ˜¯ç”¨ä¸€ä¸ª XML æ–‡æ¡£æ¥å®šä¹‰çš„ã€‚è¿™ä¸ªæ˜ å°„æ–‡æ¡£è¢«è®¾è®¡ä¸ºæ˜“è¯»çš„ï¼Œå¹¶ä¸”å¯ä»¥æ‰‹å·¥ä¿®æ”¹ã€‚æ˜ å°„è¯­è¨€æ˜¯ä»¥ Java ä¸ºä¸­å¿ƒï¼Œè¿™æ„å‘³ç€æ˜ å°„æ–‡æ¡£æ˜¯æŒ‰ç…§æŒä¹…åŒ–ç±»çš„å®šä¹‰æ¥åˆ›å»ºçš„ï¼Œè€Œéžè¡¨çš„å®šä¹‰ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Please note that even though many Hibernate users choose to write the XML by "
-"hand, a number of tools exist to generate the mapping document. These "
-"include XDoclet, Middlegen and AndroMDA."
-msgstr ""
-"请注意，虽然很多 Hibernate 用户选择手写 XML æ˜ å°„æ–‡æ¡£ï¼Œä½†ä¹Ÿæœ‰ä¸€äº›å·¥å…·å¯ä»¥ç”¨æ¥"
-"ç”Ÿæˆæ˜ å°„æ–‡æ¡£ï¼ŒåŒ…æ‹¬ XDoclet、Middlegen å’Œ AndroMDA。"
+msgid "Please note that even though many Hibernate users choose to write the XML by hand, a number of tools exist to generate the mapping document. These include XDoclet, Middlegen and AndroMDA."
+msgstr "请注意，虽然很多 Hibernate 用户选择手写 XML æ˜ å°„æ–‡æ¡£ï¼Œä½†ä¹Ÿæœ‰ä¸€äº›å·¥å…·å¯ä»¥ç”¨æ¥ç”Ÿæˆæ˜ å°„æ–‡æ¡£ï¼ŒåŒ…æ‹¬ XDoclet、Middlegen å’Œ AndroMDA。"
 
 #. Tag: para
 #, no-c-format
@@ -54,16 +42,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"We will now discuss the content of the mapping document. We will only "
-"describe, however, the document elements and attributes that are used by "
-"Hibernate at runtime. The mapping document also contains some extra optional "
-"attributes and elements that affect the database schemas exported by the "
-"schema export tool (for example, the <literal> not-null</literal> attribute)."
-msgstr ""
-"æˆ‘ä»¬çŽ°åœ¨å¼€å§‹è®¨è®ºæ˜ å°„æ–‡æ¡£çš„å†…å®¹ã€‚æˆ‘ä»¬åªæè¿° Hibernate åœ¨è¿è¡Œæ—¶ç”¨åˆ°çš„æ–‡æ¡£å…ƒç´ å’Œ"
-"å±žæ€§ã€‚æ˜ å°„æ–‡æ¡£è¿˜åŒ…æ‹¬ä¸€äº›é¢å¤–çš„å¯é€‰å±žæ€§å’Œå…ƒç´ ï¼Œå®ƒä»¬åœ¨ä½¿ç”¨ schema 导出工具的时"
-"候会影响导出的数据库 schema 结果（比如，<literal>not-null</literal> 属性）。"
+msgid "We will now discuss the content of the mapping document. We will only describe, however, the document elements and attributes that are used by Hibernate at runtime. The mapping document also contains some extra optional attributes and elements that affect the database schemas exported by the schema export tool (for example, the <literal> not-null</literal> attribute)."
+msgstr "æˆ‘ä»¬çŽ°åœ¨å¼€å§‹è®¨è®ºæ˜ å°„æ–‡æ¡£çš„å†…å®¹ã€‚æˆ‘ä»¬åªæè¿° Hibernate åœ¨è¿è¡Œæ—¶ç”¨åˆ°çš„æ–‡æ¡£å…ƒç´ å’Œå±žæ€§ã€‚æ˜ å°„æ–‡æ¡£è¿˜åŒ…æ‹¬ä¸€äº›é¢å¤–çš„å¯é€‰å±žæ€§å’Œå…ƒç´ ï¼Œå®ƒä»¬åœ¨ä½¿ç”¨ schema 导出工具的时候会影响导出的数据库 schema 结果（比如，<literal>not-null</literal> 属性）。"
 
 #. Tag: title
 #, no-c-format
@@ -72,19 +52,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"All XML mappings should declare the doctype shown. The actual DTD can be "
-"found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/"
-"hibernate </literal>, or in <literal>hibernate3.jar</literal>. Hibernate "
-"will always look for the DTD in its classpath first. If you experience "
-"lookups of the DTD using an Internet connection, check the DTD declaration "
-"against the contents of your classpath."
-msgstr ""
-"所有的 XML æ˜ å°„éƒ½éœ€è¦å®šä¹‰å¦‚ä¸Šæ‰€ç¤ºçš„ doctype。DTD 可以从上述 URL 中获取，也可"
-"以从 <literal>hibernate-x.x.x/src/org/hibernate </literal> 目录中、或 "
-"<literal>hibernate.jar</literal> 文件中找到。Hibernate 总是会首先在它的 "
-"classptah 中搜索 DTD æ–‡ä»¶ã€‚å¦‚æžœä½ å‘çŽ°å®ƒæ˜¯é€šè¿‡è¿žæŽ¥ Internet 查找 DTD 文件，就"
-"å¯¹ç…§ä½ çš„ classpath 目录检查 XML 文件里的 DTD 声明。"
+msgid "All XML mappings should declare the doctype shown. The actual DTD can be found at the URL above, in the directory <literal>hibernate-x.x.x/src/org/hibernate </literal>, or in <literal>hibernate3.jar</literal>. Hibernate will always look for the DTD in its classpath first. If you experience lookups of the DTD using an Internet connection, check the DTD declaration against the contents of your classpath."
+msgstr "所有的 XML æ˜ å°„éƒ½éœ€è¦å®šä¹‰å¦‚ä¸Šæ‰€ç¤ºçš„ doctype。DTD 可以从上述 URL 中获取，也可以从 <literal>hibernate-x.x.x/src/org/hibernate </literal> 目录中、或 <literal>hibernate.jar</literal> 文件中找到。Hibernate 总是会首先在它的 classptah 中搜索 DTD æ–‡ä»¶ã€‚å¦‚æžœä½ å‘çŽ°å®ƒæ˜¯é€šè¿‡è¿žæŽ¥ Internet 查找 DTD æ–‡ä»¶ï¼Œå°±å¯¹ç…§ä½ çš„ classpath 目录检查 XML 文件里的 DTD 声明。"
 
 #. Tag: title
 #, no-c-format
@@ -93,44 +62,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate will first attempt to resolve DTDs in its classpath. It does this "
-"is by registering a custom <literal>org.xml.sax.EntityResolver</literal> "
-"implementation with the SAXReader it uses to read in the xml files. This "
-"custom <literal>EntityResolver</literal> recognizes two different systemId "
-"namespaces:"
-msgstr ""
-"Hibernate 首先试图在其 classpath 中解析 DTDã€‚è¿™æ˜¯ä¾é åœ¨ç³»ç»Ÿä¸­æ³¨å†Œçš„ "
-"<literal>org.xml.sax.EntityResolver</literal> 的一个具体实现，SAXReader ä¾é "
-"它来读取 xml 文件。这个自定义的 <literal>EntityResolver</literal> 能辨认两种"
-"不同的 systenId 命名空间："
+msgid "Hibernate will first attempt to resolve DTDs in its classpath. It does this is by registering a custom <literal>org.xml.sax.EntityResolver</literal> implementation with the SAXReader it uses to read in the xml files. This custom <literal>EntityResolver</literal> recognizes two different systemId namespaces:"
+msgstr "Hibernate 首先试图在其 classpath 中解析 DTDã€‚è¿™æ˜¯ä¾é åœ¨ç³»ç»Ÿä¸­æ³¨å†Œçš„ <literal>org.xml.sax.EntityResolver</literal> 的一个具体实现，SAXReader ä¾é å®ƒæ¥è¯»å– xml 文件。这个自定义的 <literal>EntityResolver</literal> 能辨认两种不同的 systenId 命名空间："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"a <literal>hibernate namespace</literal> is recognized whenever the resolver "
-"encounters a systemId starting with <literal>http://hibernate.sourceforge."
-"net/</literal>. The resolver attempts to resolve these entities via the "
-"classloader which loaded the Hibernate classes."
-msgstr ""
-"若 resolver 遇到了一个以 <literal>http://hibernate.sourceforge.net/</"
-"literal> 为开头的 systemId，它会辨认出是 <literal>hibernate namespace</"
-"literal>，resolver å°±è¯•å›¾é€šè¿‡åŠ è½½ Hibernate 类的 classloader 来查找这些实"
-"体。 "
+msgid "a <literal>hibernate namespace</literal> is recognized whenever the resolver encounters a systemId starting with <literal>http://hibernate.sourceforge.net/</literal>. The resolver attempts to resolve these entities via the classloader which loaded the Hibernate classes."
+msgstr "è‹¥ resolver 遇到了一个以 <literal>http://hibernate.sourceforge.net/</literal> 为开头的 systemId，它会辨认出是 <literal>hibernate namespace</literal>，resolver å°±è¯•å›¾é€šè¿‡åŠ è½½ Hibernate 类的 classloader 来查找这些实体。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"a <literal>user namespace</literal> is recognized whenever the resolver "
-"encounters a systemId using a <literal>classpath://</literal> URL protocol. "
-"The resolver will attempt to resolve these entities via (1) the current "
-"thread context classloader and (2) the classloader which loaded the "
-"Hibernate classes."
-msgstr ""
-"若 resolver 遇到了一个使用 <literal>classpath://</literal> URL 协议的 "
-"systemId，它会辨认出这是 <literal>user namespace</literal>，resolver 试图通过"
-"（1) 当前线程上下文的 classloader 和（2) åŠ è½½ Hibernate class çš„ classloader "
-"来查找这些实体。"
+msgid "a <literal>user namespace</literal> is recognized whenever the resolver encounters a systemId using a <literal>classpath://</literal> URL protocol. The resolver will attempt to resolve these entities via (1) the current thread context classloader and (2) the classloader which loaded the Hibernate classes."
+msgstr "è‹¥ resolver 遇到了一个使用 <literal>classpath://</literal> URL 协议的 systemId，它会辨认出这是 <literal>user namespace</literal>，resolver 试图通过（1) 当前线程上下文的 classloader 和（2) åŠ è½½ Hibernate class çš„ classloader 来查找这些实体。"
 
 #. Tag: para
 #, no-c-format
@@ -138,14 +81,9 @@
 msgstr "下面是一个使用用户命名空间（user namespace）的例子："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Where <literal>types.xml</literal> is a resource in the <literal>your."
-"domain</literal> package and contains a custom <xref linkend=\"mapping-types-"
-"custom\" />."
-msgstr ""
-"这里的 <literal>types.xml</literal> 是 <literal>your.domain</literal> 包中的"
-"一个资源，它包含了一个自定义的 <xref linkend=\"mapping-types-custom\"/>。"
+#, no-c-format
+msgid "Where <literal>types.xml</literal> is a resource in the <literal>your.domain</literal> package and contains a custom <xref linkend=\"mapping-types-custom\" />."
+msgstr "这里的 <literal>types.xml</literal> 是 <literal>your.domain</literal> 包中的一个资源，它包含了一个自定义的 <xref linkend=\"mapping-types-custom\"/>。 "
 
 #. Tag: title
 #, no-c-format
@@ -154,25 +92,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This element has several optional attributes. The <literal>schema</literal> "
-"and <literal>catalog</literal> attributes specify that tables referred to in "
-"this mapping belong to the named schema and/or catalog. If they are "
-"specified, tablenames will be qualified by the given schema and catalog "
-"names. If they are missing, tablenames will be unqualified. The "
-"<literal>default-cascade</literal> attribute specifies what cascade style "
-"should be assumed for properties and collections that do not specify a "
-"<literal>cascade</literal> attribute. By default, the <literal>auto-import</"
-"literal> attribute allows you to use unqualified class names in the query "
-"language."
-msgstr ""
-"è¿™ä¸ªå…ƒç´ åŒ…æ‹¬ä¸€äº›å¯é€‰çš„å±žæ€§ã€‚<literal>schema</literal> å’Œ <literal>catalog</"
-"literal> 属性， æŒ‡æ˜Žäº†è¿™ä¸ªæ˜ å°„æ‰€è¿žæŽ¥ï¼ˆrefer）的表所在的 schema å’Œ/或 catalog "
-"åç§°ã€‚å‡è‹¥æŒ‡å®šäº†è¿™ä¸ªå±žæ€§ï¼Œè¡¨åä¼šåŠ ä¸Šæ‰€æŒ‡å®šçš„ schema å’Œ catalog 的名字扩展为全"
-"限定名。假若没有指定，表名就不会使用全限定名。<literal>default-cascade</"
-"literal> 指定了未明确注明 <literal>cascade</literal> 属性的 Java 属性和 集合"
-"ç±» Hibernate ä¼šé‡‡å–ä»€ä¹ˆæ ·çš„é»˜è®¤çº§è”é£Žæ ¼ã€‚<literal>auto-import</literal> 属性"
-"默认让我们在查询语言中可以使用非全限定名的类名。"
+msgid "This element has several optional attributes. The <literal>schema</literal> and <literal>catalog</literal> attributes specify that tables referred to in this mapping belong to the named schema and/or catalog. If they are specified, tablenames will be qualified by the given schema and catalog names. If they are missing, tablenames will be unqualified. The <literal>default-cascade</literal> attribute specifies what cascade style should be assumed for properties and collections that do not specify a <literal>cascade</literal> attribute. By default, the <literal>auto-import</literal> attribute allows you to use unqualified class names in the query language."
+msgstr "è¿™ä¸ªå…ƒç´ åŒ…æ‹¬ä¸€äº›å¯é€‰çš„å±žæ€§ã€‚<literal>schema</literal> å’Œ <literal>catalog</literal> 属性， æŒ‡æ˜Žäº†è¿™ä¸ªæ˜ å°„æ‰€è¿žæŽ¥ï¼ˆrefer）的表所在的 schema å’Œ/或 catalog åç§°ã€‚å‡è‹¥æŒ‡å®šäº†è¿™ä¸ªå±žæ€§ï¼Œè¡¨åä¼šåŠ ä¸Šæ‰€æŒ‡å®šçš„ schema å’Œ catalog 的名字扩展为全限定名。假若没有指定，表名就不会使用全限定名。<literal>default-cascade</literal> 指定了未明确注明 <literal>cascade</literal> 属性的 Java 属性和 集合类 Hibernate ä¼šé‡‡å–ä»€ä¹ˆæ ·çš„é»˜è®¤çº§è”é£Žæ ¼ã€‚<literal>auto-import</literal> 属性默认让我们在查询语言中可以使用非全限定名的类名。"
 
 #. Tag: para
 #, no-c-format
@@ -186,81 +107,38 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>default-cascade</literal> (optional - defaults to <literal>none</"
-"literal>): a default cascade style."
-msgstr ""
-"<literal>default-cascade</literal>（可选 — 默认为 <literal>none</literal>）："
-"é»˜è®¤çš„çº§è”é£Žæ ¼ã€‚ "
+msgid "<literal>default-cascade</literal> (optional - defaults to <literal>none</literal>): a default cascade style."
+msgstr "<literal>default-cascade</literal>（可选 — 默认为 <literal>none</literal>ï¼‰ï¼šé»˜è®¤çš„çº§è”é£Žæ ¼ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>default-access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate should use for accessing all properties. "
-"It can be a custom implementation of <literal>PropertyAccessor</literal>."
-msgstr ""
-"<literal>default-access</literal>（可选 — 默认为 <literal>property</"
-"literal>）：Hibernate 用来访问所有属性的策略。可以通过实现 "
-"<literal>PropertyAccessor</literal> 接口自定义。 "
+msgid "<literal>default-access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate should use for accessing all properties. It can be a custom implementation of <literal>PropertyAccessor</literal>."
+msgstr "<literal>default-access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问所有属性的策略。可以通过实现 <literal>PropertyAccessor</literal> 接口自定义。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>default-lazy</literal> (optional - defaults to <literal>true</"
-"literal>): the default value for unspecified <literal>lazy</literal> "
-"attributes of class and collection mappings."
-msgstr ""
-"<literal>default-lazy</literal>（可选 — 默认为 <literal>true</literal>）：指"
-"定了未明确注明 <literal>lazy</literal> 属性的 Java 属性和集合类，Hibernate 会"
-"é‡‡å–ä»€ä¹ˆæ ·çš„é»˜è®¤åŠ è½½é£Žæ ¼ã€‚ "
+msgid "<literal>default-lazy</literal> (optional - defaults to <literal>true</literal>): the default value for unspecified <literal>lazy</literal> attributes of class and collection mappings."
+msgstr "<literal>default-lazy</literal>（可选 — 默认为 <literal>true</literal>）：指定了未明确注明 <literal>lazy</literal> 属性的 Java 属性和集合类，Hibernate ä¼šé‡‡å–ä»€ä¹ˆæ ·çš„é»˜è®¤åŠ è½½é£Žæ ¼ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>auto-import</literal> (optional - defaults to <literal>true</"
-"literal>): specifies whether we can use unqualified class names of classes "
-"in this mapping in the query language."
-msgstr ""
-"<literal>auto-import</literal>（可选 — 默认为 <literal>true</literal>）：指定"
-"æˆ‘ä»¬æ˜¯å¦å¯ä»¥åœ¨æŸ¥è¯¢è¯­è¨€ä¸­ä½¿ç”¨éžå…¨é™å®šçš„ç±»åï¼ˆä»…é™äºŽæœ¬æ˜ å°„æ–‡ä»¶ä¸­çš„ç±»ï¼‰ã€‚ "
+msgid "<literal>auto-import</literal> (optional - defaults to <literal>true</literal>): specifies whether we can use unqualified class names of classes in this mapping in the query language."
+msgstr "<literal>auto-import</literal>（可选 — 默认为 <literal>true</literal>ï¼‰ï¼šæŒ‡å®šæˆ‘ä»¬æ˜¯å¦å¯ä»¥åœ¨æŸ¥è¯¢è¯­è¨€ä¸­ä½¿ç”¨éžå…¨é™å®šçš„ç±»åï¼ˆä»…é™äºŽæœ¬æ˜ å°„æ–‡ä»¶ä¸­çš„ç±»ï¼‰ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>package</literal> (optional): specifies a package prefix to use for "
-"unqualified class names in the mapping document."
-msgstr ""
-"<literal>package</literal>ï¼ˆå¯é€‰ï¼‰ï¼šæŒ‡å®šä¸€ä¸ªåŒ…å‰ç¼€ï¼Œå¦‚æžœåœ¨æ˜ å°„æ–‡æ¡£ä¸­æ²¡æœ‰æŒ‡å®š"
-"全限定的类名，就使用这个作为包名。 "
+msgid "<literal>package</literal> (optional): specifies a package prefix to use for unqualified class names in the mapping document."
+msgstr "<literal>package</literal>ï¼ˆå¯é€‰ï¼‰ï¼šæŒ‡å®šä¸€ä¸ªåŒ…å‰ç¼€ï¼Œå¦‚æžœåœ¨æ˜ å°„æ–‡æ¡£ä¸­æ²¡æœ‰æŒ‡å®šå…¨é™å®šçš„ç±»åï¼Œå°±ä½¿ç”¨è¿™ä¸ªä½œä¸ºåŒ…åã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you have two persistent classes with the same unqualified name, you "
-"should set <literal>auto-import=\"false\"</literal>. An exception will "
-"result if you attempt to assign two classes to the same \"imported\" name."
-msgstr ""
-"å‡è‹¥ä½ æœ‰ä¸¤ä¸ªæŒä¹…åŒ–ç±»ï¼Œå®ƒä»¬çš„éžå…¨é™å®šåæ˜¯ä¸€æ ·çš„ï¼ˆå°±æ˜¯ä¸¤ä¸ªç±»çš„åå­—ä¸€æ ·ï¼Œæ‰€åœ¨çš„"
-"åŒ…ä¸ä¸€æ · — è¯‘è€…æ³¨ï¼‰ï¼Œä½ åº”è¯¥è®¾ç½® <literal>auto-import=\"false\"</literal>。如"
-"æžœä½ æŠŠä¸€ä¸ªâ€œå¯¼å…¥è¿‡â€çš„åå­—åŒæ—¶å¯¹åº”ä¸¤ä¸ªç±»ï¼ŒHibernate 会抛出一个异常。"
+msgid "If you have two persistent classes with the same unqualified name, you should set <literal>auto-import=\"false\"</literal>. An exception will result if you attempt to assign two classes to the same \"imported\" name."
+msgstr "å‡è‹¥ä½ æœ‰ä¸¤ä¸ªæŒä¹…åŒ–ç±»ï¼Œå®ƒä»¬çš„éžå…¨é™å®šåæ˜¯ä¸€æ ·çš„ï¼ˆå°±æ˜¯ä¸¤ä¸ªç±»çš„åå­—ä¸€æ ·ï¼Œæ‰€åœ¨çš„åŒ…ä¸ä¸€æ · — è¯‘è€…æ³¨ï¼‰ï¼Œä½ åº”è¯¥è®¾ç½® <literal>auto-import=\"false\"</literal>ã€‚å¦‚æžœä½ æŠŠä¸€ä¸ªâ€œå¯¼å…¥è¿‡â€çš„åå­—åŒæ—¶å¯¹åº”ä¸¤ä¸ªç±»ï¼ŒHibernate 会抛出一个异常。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>hibernate-mapping</literal> element allows you to nest several "
-"persistent <literal>&lt;class&gt;</literal> mappings, as shown above. It is, "
-"however, good practice (and expected by some tools) to map only a single "
-"persistent class, or a single class hierarchy, in one mapping file and name "
-"it after the persistent superclass. For example, <literal>Cat.hbm.xml</"
-"literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, "
-"<literal>Animal.hbm.xml</literal>."
-msgstr ""
-"注意 <literal>hibernate-mapping</literal> å…ƒç´ å…è®¸ä½ åµŒå¥—å¤šä¸ªå¦‚ä¸Šæ‰€ç¤ºçš„ "
-"<literal>&lt;class&gt;</literal> æ˜ å°„ã€‚ä½†æ˜¯æœ€å¥½çš„åšæ³•ï¼ˆä¹Ÿè®¸ä¸€äº›å·¥å…·éœ€è¦çš„ï¼‰æ˜¯"
-"ä¸€ä¸ªæŒä¹…åŒ–ç±»ï¼ˆæˆ–ä¸€ä¸ªç±»çš„ç»§æ‰¿å±‚æ¬¡ï¼‰å¯¹åº”ä¸€ä¸ªæ˜ å°„æ–‡ä»¶ï¼Œå¹¶ä»¥æŒä¹…åŒ–çš„è¶…ç±»åç§°å‘½"
-"名，例如：<literal>Cat.hbm.xml</literal>、<literal>Dog.hbm.xml</literal>，或"
-"者如果使用继承，<literal>Animal.hbm.xml</literal>。"
+msgid "The <literal>hibernate-mapping</literal> element allows you to nest several persistent <literal>&lt;class&gt;</literal> mappings, as shown above. It is, however, good practice (and expected by some tools) to map only a single persistent class, or a single class hierarchy, in one mapping file and name it after the persistent superclass. For example, <literal>Cat.hbm.xml</literal>, <literal>Dog.hbm.xml</literal>, or if using inheritance, <literal>Animal.hbm.xml</literal>."
+msgstr "注意 <literal>hibernate-mapping</literal> å…ƒç´ å…è®¸ä½ åµŒå¥—å¤šä¸ªå¦‚ä¸Šæ‰€ç¤ºçš„ <literal>&lt;class&gt;</literal> æ˜ å°„ã€‚ä½†æ˜¯æœ€å¥½çš„åšæ³•ï¼ˆä¹Ÿè®¸ä¸€äº›å·¥å…·éœ€è¦çš„ï¼‰æ˜¯ä¸€ä¸ªæŒä¹…åŒ–ç±»ï¼ˆæˆ–ä¸€ä¸ªç±»çš„ç»§æ‰¿å±‚æ¬¡ï¼‰å¯¹åº”ä¸€ä¸ªæ˜ å°„æ–‡ä»¶ï¼Œå¹¶ä»¥æŒä¹…åŒ–çš„è¶…ç±»åç§°å‘½åï¼Œä¾‹å¦‚ï¼š<literal>Cat.hbm.xml</literal>、<literal>Dog.hbm.xml</literal>，或者如果使用继承，<literal>Animal.hbm.xml</literal>。"
 
 #. Tag: title
 #, no-c-format
@@ -269,351 +147,153 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can declare a persistent class using the <literal>class</literal> "
-"element. For example:"
+msgid "You can declare a persistent class using the <literal>class</literal> element. For example:"
 msgstr "ä½ å¯ä»¥ä½¿ç”¨ <literal>class</literal> å…ƒç´ æ¥å®šä¹‰ä¸€ä¸ªæŒä¹…åŒ–ç±»ã€‚ä¾‹å¦‚ï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>name</literal> (optional): the fully qualified Java class name of "
-"the persistent class or interface. If this attribute is missing, it is "
-"assumed that the mapping is for a non-POJO entity."
-msgstr ""
-"<literal>name</literal>（可选）：持久化类（或者接口）的 Java 全限定名。 如果"
-"这个属性不存在，Hibernate 将假定这是一个非 POJO çš„å®žä½“æ˜ å°„ã€‚ "
+msgid "<literal>name</literal> (optional): the fully qualified Java class name of the persistent class or interface. If this attribute is missing, it is assumed that the mapping is for a non-POJO entity."
+msgstr "<literal>name</literal>（可选）：持久化类（或者接口）的 Java 全限定名。 如果这个属性不存在，Hibernate 将假定这是一个非 POJO çš„å®žä½“æ˜ å°„ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>table</literal> (optional - defaults to the unqualified class "
-"name): the name of its database table."
-msgstr ""
-"<literal>table</literal>（可选 — 默认是类的非全限定名）：对应的数据库表名。 "
+msgid "<literal>table</literal> (optional - defaults to the unqualified class name): the name of its database table."
+msgstr "<literal>table</literal>（可选 — 默认是类的非全限定名）：对应的数据库表名。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>discriminator-value</literal> (optional - defaults to the class "
-"name): a value that distinguishes individual subclasses that is used for "
-"polymorphic behavior. Acceptable values include <literal>null</literal> and "
-"<literal>not null</literal>."
-msgstr ""
-"<literal>discriminator-value</literal>（可选 — é»˜è®¤å’Œç±»åä¸€æ ·ï¼‰ï¼šä¸€ä¸ªç”¨äºŽåŒºåˆ†"
-"不同的子类的值，在多态行为时使用。它可以接受的值包括 <literal>null</literal> "
-"和 <literal>not null</literal>。 "
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): a value that distinguishes individual subclasses that is used for polymorphic behavior. Acceptable values include <literal>null</literal> and <literal>not null</literal>."
+msgstr "<literal>discriminator-value</literal>（可选 — é»˜è®¤å’Œç±»åä¸€æ ·ï¼‰ï¼šä¸€ä¸ªç”¨äºŽåŒºåˆ†ä¸åŒçš„å­ç±»çš„å€¼ï¼Œåœ¨å¤šæ€è¡Œä¸ºæ—¶ä½¿ç”¨ã€‚å®ƒå¯ä»¥æŽ¥å—çš„å€¼åŒ…æ‹¬ <literal>null</literal> å’Œ <literal>not null</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>mutable</literal> (optional - defaults to <literal>true</literal>): "
-"specifies that instances of the class are (not) mutable."
-msgstr ""
-"<literal>mutable</literal>（可选，默认值为 <literal>true</literal>）：表明该"
-"类的实例是可变的或者不可变的。 "
+msgid "<literal>mutable</literal> (optional - defaults to <literal>true</literal>): specifies that instances of the class are (not) mutable."
+msgstr "<literal>mutable</literal>（可选，默认值为 <literal>true</literal>）：表明该类的实例是可变的或者不可变的。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>schema</literal> (optional): overrides the schema name specified by "
-"the root <literal>&lt;hibernate-mapping&gt;</literal> element."
-msgstr ""
-"<literal>schema</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¦†ç›–åœ¨æ ¹ <literal>&lt;hibernate-"
-"mapping&gt;</literal> å…ƒç´ ä¸­æŒ‡å®šçš„ schema 名字。 "
+msgid "<literal>schema</literal> (optional): overrides the schema name specified by the root <literal>&lt;hibernate-mapping&gt;</literal> element."
+msgstr "<literal>schema</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¦†ç›–åœ¨æ ¹ <literal>&lt;hibernate-mapping&gt;</literal> å…ƒç´ ä¸­æŒ‡å®šçš„ schema 名字。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>catalog</literal> (optional): overrides the catalog name specified "
-"by the root <literal>&lt;hibernate-mapping&gt;</literal> element."
-msgstr ""
-"<literal>catalog</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¦†ç›–åœ¨æ ¹ <literal>&lt;hibernate-"
-"mapping&gt;</literal> å…ƒç´ ä¸­æŒ‡å®šçš„ catalog 名字。 "
+msgid "<literal>catalog</literal> (optional): overrides the catalog name specified by the root <literal>&lt;hibernate-mapping&gt;</literal> element."
+msgstr "<literal>catalog</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¦†ç›–åœ¨æ ¹ <literal>&lt;hibernate-mapping&gt;</literal> å…ƒç´ ä¸­æŒ‡å®šçš„ catalog 名字。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>proxy</literal> (optional): specifies an interface to use for lazy "
-"initializing proxies. You can specify the name of the class itself."
-msgstr ""
-"<literal>proxy</literal>ï¼ˆå¯é€‰ï¼‰ï¼šæŒ‡å®šä¸€ä¸ªæŽ¥å£ï¼Œåœ¨å»¶è¿Ÿè£…è½½æ—¶ä½œä¸ºä»£ç†ä½¿ç”¨ã€‚ä½ "
-"可以在这里使用该类自己的名字。 "
+msgid "<literal>proxy</literal> (optional): specifies an interface to use for lazy initializing proxies. You can specify the name of the class itself."
+msgstr "<literal>proxy</literal>ï¼ˆå¯é€‰ï¼‰ï¼šæŒ‡å®šä¸€ä¸ªæŽ¥å£ï¼Œåœ¨å»¶è¿Ÿè£…è½½æ—¶ä½œä¸ºä»£ç†ä½¿ç”¨ã€‚ä½ å¯ä»¥åœ¨è¿™é‡Œä½¿ç”¨è¯¥ç±»è‡ªå·±çš„åå­—ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>dynamic-update</literal> (optional - defaults to <literal>false</"
-"literal>): specifies that <literal>UPDATE</literal> SQL should be generated "
-"at runtime and can contain only those columns whose values have changed."
-msgstr ""
-"<literal>dynamic-update</literal>（可选，默认为 <literal>false</literal>）："
-"指定用于 <literal>UPDATE</literal> 的 SQL 将会在运行时动态生成，并且只更新那"
-"些改变过的字段。 "
+msgid "<literal>dynamic-update</literal> (optional - defaults to <literal>false</literal>): specifies that <literal>UPDATE</literal> SQL should be generated at runtime and can contain only those columns whose values have changed."
+msgstr "<literal>dynamic-update</literal>（可选，默认为 <literal>false</literal>）：指定用于 <literal>UPDATE</literal> 的 SQL 将会在运行时动态生成，并且只更新那些改变过的字段。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>dynamic-insert</literal> (optional - defaults to <literal>false</"
-"literal>): specifies that <literal>INSERT</literal> SQL should be generated "
-"at runtime and contain only the columns whose values are not null."
-msgstr ""
-"<literal>dynamic-insert</literal>（可选，默认为 <literal>false</literal>）："
-"指定用于 <literal>INSERT</literal> 的 SQL 将会在运行时动态生成，并且只包含那"
-"些非空值字段。 "
+msgid "<literal>dynamic-insert</literal> (optional - defaults to <literal>false</literal>): specifies that <literal>INSERT</literal> SQL should be generated at runtime and contain only the columns whose values are not null."
+msgstr "<literal>dynamic-insert</literal>（可选，默认为 <literal>false</literal>）：指定用于 <literal>INSERT</literal> 的 SQL 将会在运行时动态生成，并且只包含那些非空值字段。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>select-before-update</literal> (optional - defaults to "
-"<literal>false</literal>): specifies that Hibernate should <emphasis>never</"
-"emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that "
-"an object is actually modified. Only when a transient object has been "
-"associated with a new session using <literal>update()</literal>, will "
-"Hibernate perform an extra SQL <literal>SELECT</literal> to determine if an "
-"<literal>UPDATE</literal> is actually required."
-msgstr ""
-"<literal>select-before-update</literal>（可选，默认为 <literal>false</"
-"literal>）：指定 Hibernate 除非确定对象真正被修改了（如果该值为 true — 译"
-"注），否则<emphasis>不会</emphasis>执行 SQL <literal>UPDATE</literal> 操作。"
-"在特定场合（实际上，它只在一个瞬时对象（transient object）关联到一个新的 "
-"session 中时执行的 update() 中生效），这说明 Hibernate 会在 <literal>UPDATE</"
-"literal> 之前执行一次额外的 SQL <literal>SELECT</literal> 操作来决定是否确实"
-"需要执行 <literal>UPDATE</literal>。"
+msgid "<literal>select-before-update</literal> (optional - defaults to <literal>false</literal>): specifies that Hibernate should <emphasis>never</emphasis> perform an SQL <literal>UPDATE</literal> unless it is certain that an object is actually modified. Only when a transient object has been associated with a new session using <literal>update()</literal>, will Hibernate perform an extra SQL <literal>SELECT</literal> to determine if an <literal>UPDATE</literal> is actually required."
+msgstr "<literal>select-before-update</literal>（可选，默认为 <literal>false</literal>）：指定 Hibernate 除非确定对象真正被修改了（如果该值为 true — 译注），否则<emphasis>不会</emphasis>执行 SQL <literal>UPDATE</literal> 操作。在特定场合（实际上，它只在一个瞬时对象（transient object）关联到一个新的 session 中时执行的 update() 中生效），这说明 Hibernate 会在 <literal>UPDATE</literal> 之前执行一次额外的 SQL <literal>SELECT</literal> 操作来决定是否确实需要执行 <literal>UPDATE</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>polymorphism</literal> (optional - defaults to <literal>implicit</"
-"literal>): determines whether implicit or explicit query polymorphism is "
-"used."
-msgstr ""
-"<literal>polymorphism（多态）</literal>（可选，默认值为 <literal>implicit "
-"（隐式）</literal>）：界定是隐式还是显式的使用多态查询（这只在 Hibernate 的具"
-"体表继承策略中用到 — 译注）。 "
+msgid "<literal>polymorphism</literal> (optional - defaults to <literal>implicit</literal>): determines whether implicit or explicit query polymorphism is used."
+msgstr "<literal>polymorphism（多态）</literal>（可选，默认值为 <literal>implicit （隐式）</literal>）：界定是隐式还是显式的使用多态查询（这只在 Hibernate 的具体表继承策略中用到 — 译注）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>where</literal> (optional): specifies an arbitrary SQL "
-"<literal>WHERE</literal> condition to be used when retrieving objects of "
-"this class."
-msgstr ""
-"<literal>where</literal>ï¼ˆå¯é€‰ï¼‰æŒ‡å®šä¸€ä¸ªé™„åŠ çš„ SQL <literal>WHERE</literal> "
-"æ¡ä»¶ï¼Œåœ¨æŠ“å–è¿™ä¸ªç±»çš„å¯¹è±¡æ—¶ä¼šä¸€ç›´å¢žåŠ è¿™ä¸ªæ¡ä»¶ã€‚ "
+msgid "<literal>where</literal> (optional): specifies an arbitrary SQL <literal>WHERE</literal> condition to be used when retrieving objects of this class."
+msgstr "<literal>where</literal>ï¼ˆå¯é€‰ï¼‰æŒ‡å®šä¸€ä¸ªé™„åŠ çš„ SQL <literal>WHERE</literal> æ¡ä»¶ï¼Œåœ¨æŠ“å–è¿™ä¸ªç±»çš„å¯¹è±¡æ—¶ä¼šä¸€ç›´å¢žåŠ è¿™ä¸ªæ¡ä»¶ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>persister</literal> (optional): specifies a custom "
-"<literal>ClassPersister</literal>."
-msgstr ""
-"<literal>persister</literal>（可选）：指定一个定制的 "
-"<literal>ClassPersister</literal>。 "
+msgid "<literal>persister</literal> (optional): specifies a custom <literal>ClassPersister</literal>."
+msgstr "<literal>persister</literal>（可选）：指定一个定制的 <literal>ClassPersister</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>batch-size</literal> (optional - defaults to <literal>1</literal>): "
-"specifies a \"batch size\" for fetching instances of this class by "
-"identifier."
-msgstr ""
-"<literal>batch-size</literal>（可选,默认是 <literal>1</literal>）指定一个用"
-"于 æ ¹æ®æ ‡è¯†ç¬¦ï¼ˆidentifier）抓取实例时使用的 \"batch size\"（批次抓取数量）。 "
+msgid "<literal>batch-size</literal> (optional - defaults to <literal>1</literal>): specifies a \"batch size\" for fetching instances of this class by identifier."
+msgstr "<literal>batch-size</literal>（可选,默认是 <literal>1</literal>）指定一个用于 æ ¹æ®æ ‡è¯†ç¬¦ï¼ˆidentifier）抓取实例时使用的 \"batch size\"（批次抓取数量）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>version</"
-"literal>): determines the optimistic locking strategy."
-msgstr ""
-"<literal>optimistic-lock（乐观锁定）</literal>（可选，默认是 "
-"<literal>version</literal>）：决定乐观锁定的策略。 "
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>version</literal>): determines the optimistic locking strategy."
+msgstr "<literal>optimistic-lock（乐观锁定）</literal>（可选，默认是 <literal>version</literal>）：决定乐观锁定的策略。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional): lazy fetching can be disabled by setting "
-"<literal>lazy=\"false\"</literal>."
-msgstr ""
-"<literal>lazy</literal>（可选）：通过设置 <literal>lazy=\"false\"</literal>，"
-"æ‰€æœ‰çš„å»¶è¿ŸåŠ è½½ï¼ˆLazy fetching）功能将被全部禁用（disabled）。"
+msgid "<literal>lazy</literal> (optional): lazy fetching can be disabled by setting <literal>lazy=\"false\"</literal>."
+msgstr "<literal>lazy</literal>（可选）：通过设置 <literal>lazy=\"false\"</literal>ï¼Œæ‰€æœ‰çš„å»¶è¿ŸåŠ è½½ï¼ˆLazy fetching）功能将被全部禁用（disabled）。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>entity-name</literal> (optional - defaults to the class name): "
-"Hibernate3 allows a class to be mapped multiple times, potentially to "
-"different tables. It also allows entity mappings that are represented by "
-"Maps or XML at the Java level. In these cases, you should provide an "
-"explicit arbitrary name for the entity. See <xref linkend=\"persistent-"
-"classes-dynamicmodels\" /> and <xref linkend=\"xml\" /> for more information."
-msgstr ""
-"<literal>entity-name</literal>（可选，默认为类名）：Hibernate3 允许一个类进行"
-"å¤šæ¬¡æ˜ å°„ï¼ˆå‰ææ˜¯æ˜ å°„åˆ°ä¸åŒçš„è¡¨ï¼‰ï¼Œå¹¶ä¸”å…è®¸ä½¿ç”¨ Maps 或 XML 代替 Java 层次的实"
-"ä½“æ˜ å°„ï¼ˆä¹Ÿå°±æ˜¯å®žçŽ°åŠ¨æ€é¢†åŸŸæ¨¡åž‹ï¼Œä¸ç”¨å†™æŒä¹…åŒ–ç±»ï¼è¯‘æ³¨ï¼‰ã€‚æ›´å¤šä¿¡æ¯è¯·çœ‹ <xref "
-"linkend=\"persistent-classes-dynamicmodels\"/> 和 <xref linkend=\"xml\"/>。"
+#, no-c-format
+msgid "<literal>entity-name</literal> (optional - defaults to the class name): Hibernate3 allows a class to be mapped multiple times, potentially to different tables. It also allows entity mappings that are represented by Maps or XML at the Java level. In these cases, you should provide an explicit arbitrary name for the entity. See <xref linkend=\"persistent-classes-dynamicmodels\" /> and <xref linkend=\"xml\" /> for more information."
+msgstr "<literal>entity-name</literal>（可选，默认为类名）：Hibernate3 å…è®¸ä¸€ä¸ªç±»è¿›è¡Œå¤šæ¬¡æ˜ å°„ï¼ˆå‰ææ˜¯æ˜ å°„åˆ°ä¸åŒçš„è¡¨ï¼‰ï¼Œå¹¶ä¸”å…è®¸ä½¿ç”¨ Maps 或 XML 代替 Java å±‚æ¬¡çš„å®žä½“æ˜ å°„ï¼ˆä¹Ÿå°±æ˜¯å®žçŽ°åŠ¨æ€é¢†åŸŸæ¨¡åž‹ï¼Œä¸ç”¨å†™æŒä¹…åŒ–ç±»ï¼è¯‘æ³¨ï¼‰ã€‚æ›´å¤šä¿¡æ¯è¯·çœ‹ <xref linkend=\"persistent-classes-dynamicmodels\"/> å’Œ <xref linkend=\"xml\"/>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>check</literal> (optional): an SQL expression used to generate a "
-"multi-row <emphasis>check</emphasis> constraint for automatic schema "
-"generation."
-msgstr ""
-"<literal>check</literal>（可选）：这是一个 SQL 表达式， 用于为自动生成的 "
-"schema æ·»åŠ å¤šè¡Œï¼ˆmulti-row）约束<emphasis>检查</emphasis>。 "
+msgid "<literal>check</literal> (optional): an SQL expression used to generate a multi-row <emphasis>check</emphasis> constraint for automatic schema generation."
+msgstr "<literal>check</literal>（可选）：这是一个 SQL 表达式， 用于为自动生成的 schema æ·»åŠ å¤šè¡Œï¼ˆmulti-row）约束<emphasis>检查</emphasis>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>rowid</literal> (optional): Hibernate can use ROWIDs on databases. "
-"On Oracle, for example, Hibernate can use the <literal>rowid</literal> extra "
-"column for fast updates once this option has been set to <literal>rowid</"
-"literal>. A ROWID is an implementation detail and represents the physical "
-"location of a stored tuple."
-msgstr ""
-"<literal>rowid</literal>（可选）：Hibernate 可以使用数据库支持的所谓的 "
-"ROWIDs，例如：Oracle æ•°æ®åº“ï¼Œå¦‚æžœä½ è®¾ç½®è¿™ä¸ªå¯é€‰çš„ <literal>rowid</literal>，"
-"Hibernate 可以使用额外的字段 <literal>rowid</literal> 实现快速更新。ROWID 是"
-"这个功能实现的重点，它代表了一个存储元组（tuple）的物理位置。 "
+msgid "<literal>rowid</literal> (optional): Hibernate can use ROWIDs on databases. On Oracle, for example, Hibernate can use the <literal>rowid</literal> extra column for fast updates once this option has been set to <literal>rowid</literal>. A ROWID is an implementation detail and represents the physical location of a stored tuple."
+msgstr "<literal>rowid</literal>（可选）：Hibernate 可以使用数据库支持的所谓的 ROWIDs，例如：Oracle æ•°æ®åº“ï¼Œå¦‚æžœä½ è®¾ç½®è¿™ä¸ªå¯é€‰çš„ <literal>rowid</literal>，Hibernate 可以使用额外的字段 <literal>rowid</literal> 实现快速更新。ROWID 是这个功能实现的重点，它代表了一个存储元组（tuple）的物理位置。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>subselect</literal> (optional): maps an immutable and read-only "
-"entity to a database subselect. This is useful if you want to have a view "
-"instead of a base table. See below for more information."
-msgstr ""
-"<literal>subselect</literal>（可选）：它将一个不可变（immutable）并且只读的实"
-"ä½“æ˜ å°„åˆ°ä¸€ä¸ªæ•°æ®åº“çš„å­æŸ¥è¯¢ä¸­ã€‚å½“ä½ æƒ³ç”¨è§†å›¾ä»£æ›¿ä¸€å¼ åŸºæœ¬è¡¨çš„æ—¶å€™ï¼Œè¿™æ˜¯æœ‰ç”¨çš„ï¼Œ"
-"ä½†æœ€å¥½ä¸è¦è¿™æ ·åšã€‚æ›´å¤šçš„ä»‹ç»è¯·çœ‹ä¸‹é¢å†…å®¹ã€‚ "
+msgid "<literal>subselect</literal> (optional): maps an immutable and read-only entity to a database subselect. This is useful if you want to have a view instead of a base table. See below for more information."
+msgstr "<literal>subselect</literal>（可选）：它将一个不可变（immutableï¼‰å¹¶ä¸”åªè¯»çš„å®žä½“æ˜ å°„åˆ°ä¸€ä¸ªæ•°æ®åº“çš„å­æŸ¥è¯¢ä¸­ã€‚å½“ä½ æƒ³ç”¨è§†å›¾ä»£æ›¿ä¸€å¼ åŸºæœ¬è¡¨çš„æ—¶å€™ï¼Œè¿™æ˜¯æœ‰ç”¨çš„ï¼Œä½†æœ€å¥½ä¸è¦è¿™æ ·åšã€‚æ›´å¤šçš„ä»‹ç»è¯·çœ‹ä¸‹é¢å†…å®¹ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>abstract</literal> (optional): is used to mark abstract "
-"superclasses in <literal>&lt;union-subclass&gt;</literal> hierarchies."
-msgstr ""
-"<literal>abstract</literal>（可选）：用于在 <literal>&lt;union-subclass&gt;</"
-"literal> 的层次结构（hierarchiesï¼‰ä¸­æ ‡è¯†æŠ½è±¡è¶…ç±»ã€‚"
+msgid "<literal>abstract</literal> (optional): is used to mark abstract superclasses in <literal>&lt;union-subclass&gt;</literal> hierarchies."
+msgstr "<literal>abstract</literal>（可选）：用于在 <literal>&lt;union-subclass&gt;</literal> 的层次结构（hierarchiesï¼‰ä¸­æ ‡è¯†æŠ½è±¡è¶…ç±»ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is acceptable for the named persistent class to be an interface. You can "
-"declare implementing classes of that interface using the <literal>&lt;"
-"subclass&gt;</literal> element. You can persist any <emphasis>static</"
-"emphasis> inner class. Specify the class name using the standard form i.e. "
-"<literal>e.g.Foo$Bar</literal>."
-msgstr ""
-"è‹¥æŒ‡æ˜Žçš„æŒä¹…åŒ–ç±»å®žé™…ä¸Šæ˜¯ä¸€ä¸ªæŽ¥å£ï¼Œè¿™ä¹Ÿæ˜¯å®Œå…¨å¯ä»¥æŽ¥å—çš„ã€‚ä¹‹åŽä½ å¯ä»¥ç”¨å…ƒç´  "
-"<literal>&lt;subclass&gt;</literal> æ¥æŒ‡å®šè¯¥æŽ¥å£çš„å®žé™…å®žçŽ°ç±»ã€‚ä½ å¯ä»¥æŒä¹…åŒ–ä»»"
-"何 <emphasis>static</emphasis>ï¼ˆé™æ€çš„ï¼‰å†…éƒ¨ç±»ã€‚ä½ åº”è¯¥ä½¿ç”¨æ ‡å‡†çš„ç±»åæ ¼å¼æ¥æŒ‡"
-"定类名，比如：<literal>Foo$Bar</literal>。"
+msgid "It is acceptable for the named persistent class to be an interface. You can declare implementing classes of that interface using the <literal>&lt;subclass&gt;</literal> element. You can persist any <emphasis>static</emphasis> inner class. Specify the class name using the standard form i.e. <literal>e.g.Foo$Bar</literal>."
+msgstr "è‹¥æŒ‡æ˜Žçš„æŒä¹…åŒ–ç±»å®žé™…ä¸Šæ˜¯ä¸€ä¸ªæŽ¥å£ï¼Œè¿™ä¹Ÿæ˜¯å®Œå…¨å¯ä»¥æŽ¥å—çš„ã€‚ä¹‹åŽä½ å¯ä»¥ç”¨å…ƒç´  <literal>&lt;subclass&gt;</literal> æ¥æŒ‡å®šè¯¥æŽ¥å£çš„å®žé™…å®žçŽ°ç±»ã€‚ä½ å¯ä»¥æŒä¹…åŒ–ä»»ä½• <emphasis>static</emphasis>ï¼ˆé™æ€çš„ï¼‰å†…éƒ¨ç±»ã€‚ä½ åº”è¯¥ä½¿ç”¨æ ‡å‡†çš„ç±»åæ ¼å¼æ¥æŒ‡å®šç±»åï¼Œæ¯”å¦‚ï¼š<literal>Foo$Bar</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Immutable classes, <literal>mutable=\"false\"</literal>, cannot be updated "
-"or deleted by the application. This allows Hibernate to make some minor "
-"performance optimizations."
-msgstr ""
-"不可变类，<literal>mutable=\"false\"</literal> ä¸å¯ä»¥è¢«åº”ç”¨ç¨‹åºæ›´æ–°æˆ–è€…åˆ é™¤ã€‚"
-"这允许 Hibernate 实现一些小小的性能优化。"
+msgid "Immutable classes, <literal>mutable=\"false\"</literal>, cannot be updated or deleted by the application. This allows Hibernate to make some minor performance optimizations."
+msgstr "不可变类，<literal>mutable=\"false\"</literal> ä¸å¯ä»¥è¢«åº”ç”¨ç¨‹åºæ›´æ–°æˆ–è€…åˆ é™¤ã€‚è¿™å…è®¸ Hibernate 实现一些小小的性能优化。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The optional <literal>proxy</literal> attribute enables lazy initialization "
-"of persistent instances of the class. Hibernate will initially return CGLIB "
-"proxies that implement the named interface. The persistent object will load "
-"when a method of the proxy is invoked. See \"Initializing collections and "
-"proxies\" below."
-msgstr ""
-"可选的 <literal>proxy</literal> å±žæ€§å…è®¸å»¶è¿ŸåŠ è½½ç±»çš„æŒä¹…åŒ–å®žä¾‹ã€‚Hibernate å¼€"
-"始会返回实现了这个命名接口的 CGLIB 代理。当代理的某个方法被实际调用的时候，真"
-"实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。 "
+msgid "The optional <literal>proxy</literal> attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies that implement the named interface. The persistent object will load when a method of the proxy is invoked. See \"Initializing collections and proxies\" below."
+msgstr "可选的 <literal>proxy</literal> å±žæ€§å…è®¸å»¶è¿ŸåŠ è½½ç±»çš„æŒä¹…åŒ–å®žä¾‹ã€‚Hibernate 开始会返回实现了这个命名接口的 CGLIB 代理。当代理的某个方法被实际调用的时候，真实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Implicit</emphasis> polymorphism means that instances of the class "
-"will be returned by a query that names any superclass or implemented "
-"interface or class, and that instances of any subclass of the class will be "
-"returned by a query that names the class itself. <emphasis>Explicit</"
-"emphasis> polymorphism means that class instances will be returned only by "
-"queries that explicitly name that class. Queries that name the class will "
-"return only instances of subclasses mapped inside this <literal>&lt;class&gt;"
-"</literal> declaration as a <literal>&lt;subclass&gt;</literal> or "
-"<literal>&lt;joined-subclass&gt;</literal>. For most purposes, the default "
-"<literal>polymorphism=\"implicit\"</literal> is appropriate. Explicit "
-"polymorphism is useful when two different classes are mapped to the same "
-"table This allows a \"lightweight\" class that contains a subset of the "
-"table columns."
-msgstr ""
-"<emphasis>Implicit</emphasis>（隐式）的多态是指，如果查询时给出的是任何超类、"
-"该类实现的接口或者该类的名字，都会返回这个类的实例；如果查询中给出的是子类的"
-"名字，则会返回子类的实例。<emphasis>Explicit</emphasis>（显式）的多态是指，只"
-"有在查询时给出明确的该类名字时才会返回这个类的实例； 同时只有在这个 "
-"<literal>&lt;class&gt;</literal> 的定义中作为 <literal>&lt;subclass&gt;</"
-"literal> 或者 <literal>&lt;joined-subclass&gt;</literal> 出现的子类，才会可能"
-"返回。在大多数情况下，默认的 <literal>polymorphism=\"implicit\"</literal> 都"
-"æ˜¯åˆé€‚çš„ã€‚æ˜¾å¼çš„å¤šæ€åœ¨æœ‰ä¸¤ä¸ªä¸åŒçš„ç±»æ˜ å°„åˆ°åŒä¸€ä¸ªè¡¨çš„æ—¶å€™å¾ˆæœ‰ç”¨ã€‚ï¼ˆå…è®¸ä¸€ä¸ªâ€œè½»"
-"量级”的类，只包含部分表字段）。 "
+msgid "<emphasis>Implicit</emphasis> polymorphism means that instances of the class will be returned by a query that names any superclass or implemented interface or class, and that instances of any subclass of the class will be returned by a query that names the class itself. <emphasis>Explicit</emphasis> polymorphism means that class instances will be returned only by queries that explicitly name that class. Queries that name the class will return only instances of subclasses mapped inside this <literal>&lt;class&gt;</literal> declaration as a <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal>. For most purposes, the default <literal>polymorphism=\"implicit\"</literal> is appropriate. Explicit polymorphism is useful when two different classes are mapped to the same table This allows a \"lightweight\" class that contains a subset of the table columns."
+msgstr "<emphasis>Implicit</emphasis>（隐式）的多态是指，如果查询时给出的是任何超类、该类实现的接口或者该类的名字，都会返回这个类的实例；如果查询中给出的是子类的名字，则会返回子类的实例。<emphasis>Explicit</emphasis>（显式）的多态是指，只有在查询时给出明确的该类名字时才会返回这个类的实例； 同时只有在这个 <literal>&lt;class&gt;</literal> 的定义中作为 <literal>&lt;subclass&gt;</literal> 或者 <literal>&lt;joined-subclass&gt;</literal> 出现的子类，才会可能返回。在大多数情况下，默认的 <literal>polymorphism=\"implicit\"</literal> éƒ½æ˜¯åˆé€‚çš„ã€‚æ˜¾å¼çš„å¤šæ€åœ¨æœ‰ä¸¤ä¸ªä¸åŒçš„ç±»æ˜ å°„åˆ°åŒä¸€ä¸ªè¡¨çš„æ—¶å€™å¾ˆæœ‰ç”¨ã€‚ï¼ˆå…è®¸ä¸€ä¸ªâ€œè½»é‡çº§â€çš„ç±»ï¼ŒåªåŒ…å«éƒ¨åˆ†è¡¨å­—æ®µï¼‰ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>persister</literal> attribute lets you customize the "
-"persistence strategy used for the class. You can, for example, specify your "
-"own subclass of <literal>org.hibernate.persister.EntityPersister</literal>, "
-"or you can even provide a completely new implementation of the interface "
-"<literal>org.hibernate.persister.ClassPersister</literal> that implements, "
-"for example, persistence via stored procedure calls, serialization to flat "
-"files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for "
-"a simple example of \"persistence\" to a <literal>Hashtable</literal>."
-msgstr ""
-"<literal>persister</literal> å±žæ€§å¯ä»¥è®©ä½ å®šåˆ¶è¿™ä¸ªç±»ä½¿ç”¨çš„æŒä¹…åŒ–ç­–ç•¥ã€‚ä½ å¯ä»¥æŒ‡"
-"å®šä½ è‡ªå·±å®žçŽ° <literal>org.hibernate.persister.EntityPersister</literal> 的子"
-"ç±»ï¼Œä½ ç”šè‡³å¯ä»¥å®Œå…¨ä»Žå¤´å¼€å§‹ç¼–å†™ä¸€ä¸ª <literal>org.hibernate.persister."
-"ClassPersister</literal> 接口的实现，比如是用储存过程调用、序列化到文件或者 "
-"LDAP 数据库来实现。参阅 <literal>org.hibernate.test.CustomPersister</"
-"literal>，这是持久化到 <literal>Hashtable</literal> 的一个简单例子。 "
+msgid "The <literal>persister</literal> attribute lets you customize the persistence strategy used for the class. You can, for example, specify your own subclass of <literal>org.hibernate.persister.EntityPersister</literal>, or you can even provide a completely new implementation of the interface <literal>org.hibernate.persister.ClassPersister</literal> that implements, for example, persistence via stored procedure calls, serialization to flat files or LDAP. See <literal>org.hibernate.test.CustomPersister</literal> for a simple example of \"persistence\" to a <literal>Hashtable</literal>."
+msgstr "<literal>persister</literal> å±žæ€§å¯ä»¥è®©ä½ å®šåˆ¶è¿™ä¸ªç±»ä½¿ç”¨çš„æŒä¹…åŒ–ç­–ç•¥ã€‚ä½ å¯ä»¥æŒ‡å®šä½ è‡ªå·±å®žçŽ° <literal>org.hibernate.persister.EntityPersister</literal> çš„å­ç±»ï¼Œä½ ç”šè‡³å¯ä»¥å®Œå…¨ä»Žå¤´å¼€å§‹ç¼–å†™ä¸€ä¸ª <literal>org.hibernate.persister.ClassPersister</literal> 接口的实现，比如是用储存过程调用、序列化到文件或者 LDAP 数据库来实现。参阅 <literal>org.hibernate.test.CustomPersister</literal>，这是持久化到 <literal>Hashtable</literal> 的一个简单例子。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> "
-"settings are not inherited by subclasses, so they can also be specified on "
-"the <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</"
-"literal> elements. Although these settings can increase performance in some "
-"cases, they can actually decrease performance in others."
-msgstr ""
-"请注意 <literal>dynamic-update</literal> 和 <literal>dynamic-insert</"
-"literal> 的设置并不会继承到子类，所以在 <literal>&lt;subclass&gt;</literal> "
-"或者 <literal>&lt;joined-subclass&gt;</literal> å…ƒç´ ä¸­å¯èƒ½éœ€è¦å†æ¬¡è®¾ç½®ã€‚è¿™äº›"
-"设置在某些情况下能够提高效率，而其他情况下则反而可能降低性能。"
+msgid "The <literal>dynamic-update</literal> and <literal>dynamic-insert</literal> settings are not inherited by subclasses, so they can also be specified on the <literal>&lt;subclass&gt;</literal> or <literal>&lt;joined-subclass&gt;</literal> elements. Although these settings can increase performance in some cases, they can actually decrease performance in others."
+msgstr "请注意 <literal>dynamic-update</literal> å’Œ <literal>dynamic-insert</literal> 的设置并不会继承到子类，所以在 <literal>&lt;subclass&gt;</literal> 或者 <literal>&lt;joined-subclass&gt;</literal> å…ƒç´ ä¸­å¯èƒ½éœ€è¦å†æ¬¡è®¾ç½®ã€‚è¿™äº›è®¾ç½®åœ¨æŸäº›æƒ…å†µä¸‹èƒ½å¤Ÿæé«˜æ•ˆçŽ‡ï¼Œè€Œå…¶ä»–æƒ…å†µä¸‹åˆ™åè€Œå¯èƒ½é™ä½Žæ€§èƒ½ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Use of <literal>select-before-update</literal> will usually decrease "
-"performance. It is useful to prevent a database update trigger being called "
-"unnecessarily if you reattach a graph of detached instances to a "
-"<literal>Session</literal>."
-msgstr ""
-"使用 <literal>select-before-update</literal> é€šå¸¸ä¼šé™ä½Žæ€§èƒ½ã€‚å¦‚æžœä½ é‡æ–°è¿žæŽ¥ä¸€"
-"个脱管（detached）对象实例 到一个 <literal>Session</literal> 中时，它可以防止"
-"数据库不必要的触发 update。这就很有用了。"
+msgid "Use of <literal>select-before-update</literal> will usually decrease performance. It is useful to prevent a database update trigger being called unnecessarily if you reattach a graph of detached instances to a <literal>Session</literal>."
+msgstr "使用 <literal>select-before-update</literal> é€šå¸¸ä¼šé™ä½Žæ€§èƒ½ã€‚å¦‚æžœä½ é‡æ–°è¿žæŽ¥ä¸€ä¸ªè„±ç®¡ï¼ˆdetached）对象实例 到一个 <literal>Session</literal> 中时，它可以防止数据库不必要的触发 update。这就很有用了。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you enable <literal>dynamic-update</literal>, you will have a choice of "
-"optimistic locking strategies:"
-msgstr ""
-"å¦‚æžœä½ æ‰“å¼€äº†<literal>dynamic-update</literal>ï¼Œä½ å¯ä»¥é€‰æ‹©å‡ ç§ä¹è§‚é”å®šçš„ç­–ç•¥ï¼š"
+msgid "If you enable <literal>dynamic-update</literal>, you will have a choice of optimistic locking strategies:"
+msgstr "å¦‚æžœä½ æ‰“å¼€äº†<literal>dynamic-update</literal>ï¼Œä½ å¯ä»¥é€‰æ‹©å‡ ç§ä¹è§‚é”å®šçš„ç­–ç•¥ï¼š"
 
 #. Tag: para
 #, no-c-format
@@ -627,11 +307,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>dirty</literal>: check the changed columns, allowing some "
-"concurrent updates"
-msgstr ""
-"<literal>dirty（脏检查）</literal>：只检察修改过的字段，允许某些并行更新"
+msgid "<literal>dirty</literal>: check the changed columns, allowing some concurrent updates"
+msgstr "<literal>dirty（脏检查）</literal>：只检察修改过的字段，允许某些并行更新"
 
 #. Tag: para
 #, no-c-format
@@ -640,126 +317,68 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is <emphasis>strongly</emphasis> recommended that you use version/"
-"timestamp columns for optimistic locking with Hibernate. This strategy "
-"optimizes performance and correctly handles modifications made to detached "
-"instances (i.e. when <literal>Session.merge()</literal> is used)."
-msgstr ""
-"我们<emphasis>强烈</emphasis>å»ºè®®ä½ åœ¨ Hibernate 中使用 version/timestamp 字段"
-"来进行乐观锁定。这个选择可以优化性能，且能够处理对脱管实例的修改（例如：在使"
-"用 <literal>Session.merge()</literal> 的时候）。"
+msgid "It is <emphasis>strongly</emphasis> recommended that you use version/timestamp columns for optimistic locking with Hibernate. This strategy optimizes performance and correctly handles modifications made to detached instances (i.e. when <literal>Session.merge()</literal> is used)."
+msgstr "我们<emphasis>强烈</emphasis>å»ºè®®ä½ åœ¨ Hibernate 中使用 version/timestamp 字段来进行乐观锁定。这个选择可以优化性能，且能够处理对脱管实例的修改（例如：在使用 <literal>Session.merge()</literal> 的时候）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"There is no difference between a view and a base table for a Hibernate "
-"mapping. This is transparent at the database level, although some DBMS do "
-"not support views properly, especially with updates. Sometimes you want to "
-"use a view, but you cannot create one in the database (i.e. with a legacy "
-"schema). In this case, you can map an immutable and read-only entity to a "
-"given SQL subselect expression:"
-msgstr ""
-"对 Hibernate æ˜ å°„æ¥è¯´è§†å›¾å’Œè¡¨æ˜¯æ²¡æœ‰åŒºåˆ«çš„ï¼Œè¿™æ˜¯å› ä¸ºå®ƒä»¬åœ¨æ•°æ®å±‚éƒ½æ˜¯é€æ˜Žçš„"
-"（ æ³¨æ„ï¼šä¸€äº›æ•°æ®åº“ä¸æ”¯æŒè§†å›¾å±žæ€§ï¼Œç‰¹åˆ«æ˜¯æ›´æ–°çš„æ—¶å€™ï¼‰ã€‚æœ‰æ—¶ä½ æƒ³ä½¿ç”¨è§†å›¾ï¼Œä½†å´"
-"不能在数据库中创建它（例如：在遗留的 schema ä¸­ï¼‰ã€‚è¿™æ ·çš„è¯ï¼Œä½ å¯ä»¥æ˜ å°„ä¸€ä¸ªä¸"
-"可变的（immutable）并且是 只读的实体到一个给定的 SQL 子查询表达式： "
+msgid "There is no difference between a view and a base table for a Hibernate mapping. This is transparent at the database level, although some DBMS do not support views properly, especially with updates. Sometimes you want to use a view, but you cannot create one in the database (i.e. with a legacy schema). In this case, you can map an immutable and read-only entity to a given SQL subselect expression:"
+msgstr "对 Hibernate æ˜ å°„æ¥è¯´è§†å›¾å’Œè¡¨æ˜¯æ²¡æœ‰åŒºåˆ«çš„ï¼Œè¿™æ˜¯å› ä¸ºå®ƒä»¬åœ¨æ•°æ®å±‚éƒ½æ˜¯é€æ˜Žçš„ï¼ˆ æ³¨æ„ï¼šä¸€äº›æ•°æ®åº“ä¸æ”¯æŒè§†å›¾å±žæ€§ï¼Œç‰¹åˆ«æ˜¯æ›´æ–°çš„æ—¶å€™ï¼‰ã€‚æœ‰æ—¶ä½ æƒ³ä½¿ç”¨è§†å›¾ï¼Œä½†å´ä¸èƒ½åœ¨æ•°æ®åº“ä¸­åˆ›å»ºå®ƒï¼ˆä¾‹å¦‚ï¼šåœ¨é—ç•™çš„ schema ä¸­ï¼‰ã€‚è¿™æ ·çš„è¯ï¼Œä½ å¯ä»¥æ˜ å°„ä¸€ä¸ªä¸å¯å˜çš„ï¼ˆimmutable）并且是 只读的实体到一个给定的 SQL 子查询表达式： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Declare the tables to synchronize this entity with, ensuring that auto-flush "
-"happens correctly and that queries against the derived entity do not return "
-"stale data. The <literal>&lt;subselect&gt;</literal> is available both as an "
-"attribute and a nested mapping element."
-msgstr ""
-"定义这个实体用到的表为同步（synchronize），确保自动刷新（auto-flush）正确执"
-"è¡Œï¼Œå¹¶ä¸”ä¾èµ–åŽŸå®žä½“çš„æŸ¥è¯¢ä¸ä¼šè¿”å›žè¿‡æœŸæ•°æ®ã€‚åœ¨å±žæ€§å…ƒç´ å’ŒåµŒå¥—æ˜ å°„å…ƒç´ ä¸­éƒ½å¯ä½¿ç”¨ "
-"<literal>&lt;subselect&gt;</literal>。"
+msgid "Declare the tables to synchronize this entity with, ensuring that auto-flush happens correctly and that queries against the derived entity do not return stale data. The <literal>&lt;subselect&gt;</literal> is available both as an attribute and a nested mapping element."
+msgstr "定义这个实体用到的表为同步（synchronize），确保自动刷新（auto-flushï¼‰æ­£ç¡®æ‰§è¡Œï¼Œå¹¶ä¸”ä¾èµ–åŽŸå®žä½“çš„æŸ¥è¯¢ä¸ä¼šè¿”å›žè¿‡æœŸæ•°æ®ã€‚åœ¨å±žæ€§å…ƒç´ å’ŒåµŒå¥—æ˜ å°„å…ƒç´ ä¸­éƒ½å¯ä½¿ç”¨ <literal>&lt;subselect&gt;</literal>。"
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "id"
-msgstr "uuid"
+msgstr "id"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Mapped classes <emphasis>must</emphasis> declare the primary key column of "
-"the database table. Most classes will also have a JavaBeans-style property "
-"holding the unique identifier of an instance. The <literal>&lt;id&gt;</"
-"literal> element defines the mapping from that property to the primary key "
-"column."
-msgstr ""
-"è¢«æ˜ å°„çš„ç±»<emphasis>å¿…é¡»</emphasis>定义对应数据库表主键字段。大多数类有一个 "
-"JavaBeans é£Žæ ¼çš„å±žæ€§ï¼Œ ä¸ºæ¯ä¸€ä¸ªå®žä¾‹åŒ…å«å”¯ä¸€çš„æ ‡è¯†ã€‚<literal>&lt;id&gt;</"
-"literal> å…ƒç´ å®šä¹‰äº†è¯¥å±žæ€§åˆ°æ•°æ®åº“è¡¨ä¸»é”®å­—æ®µçš„æ˜ å°„ã€‚"
+msgid "Mapped classes <emphasis>must</emphasis> declare the primary key column of the database table. Most classes will also have a JavaBeans-style property holding the unique identifier of an instance. The <literal>&lt;id&gt;</literal> element defines the mapping from that property to the primary key column."
+msgstr "è¢«æ˜ å°„çš„ç±»<emphasis>å¿…é¡»</emphasis>定义对应数据库表主键字段。大多数类有一个 JavaBeans é£Žæ ¼çš„å±žæ€§ï¼Œ ä¸ºæ¯ä¸€ä¸ªå®žä¾‹åŒ…å«å”¯ä¸€çš„æ ‡è¯†ã€‚<literal>&lt;id&gt;</literal> å…ƒç´ å®šä¹‰äº†è¯¥å±žæ€§åˆ°æ•°æ®åº“è¡¨ä¸»é”®å­—æ®µçš„æ˜ å°„ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>name</literal> (optional): the name of the identifier property."
+msgid "<literal>name</literal> (optional): the name of the identifier property."
 msgstr "<literal>name</literal>ï¼ˆå¯é€‰ï¼‰ï¼šæ ‡è¯†å±žæ€§çš„åå­—ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>type</literal> (optional): a name that indicates the Hibernate type."
+msgid "<literal>type</literal> (optional): a name that indicates the Hibernate type."
 msgstr "<literal>type</literal>（可选）：一个 Hibernate 类型的名字。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of the primary key column."
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the primary key column."
 msgstr "<literal>column</literal>（可选 — 默认为属性名）：主键字段的名字。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" "
-"value): an identifier property value that indicates an instance is newly "
-"instantiated (unsaved), distinguishing it from detached instances that were "
-"saved or loaded in a previous session."
-msgstr ""
-"<literal>unsaved-value</literal>（可选 — 默认为一个切合实际（sensible）的"
-"å€¼ï¼‰ï¼šä¸€ä¸ªç‰¹å®šçš„æ ‡è¯†å±žæ€§å€¼ï¼Œç”¨æ¥æ ‡å¿—è¯¥å®žä¾‹æ˜¯åˆšåˆšåˆ›å»ºçš„ï¼Œå°šæœªä¿å­˜ã€‚è¿™å¯ä»¥æŠŠè¿™"
-"种实例和从以前的 session 中装载过（可能又做过修改--译者注）但未再次持久化的实"
-"例区分开来。 "
+msgid "<literal>unsaved-value</literal> (optional - defaults to a \"sensible\" value): an identifier property value that indicates an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session."
+msgstr "<literal>unsaved-value</literal>（可选 — 默认为一个切合实际（sensibleï¼‰çš„å€¼ï¼‰ï¼šä¸€ä¸ªç‰¹å®šçš„æ ‡è¯†å±žæ€§å€¼ï¼Œç”¨æ¥æ ‡å¿—è¯¥å®žä¾‹æ˜¯åˆšåˆšåˆ›å»ºçš„ï¼Œå°šæœªä¿å­˜ã€‚è¿™å¯ä»¥æŠŠè¿™ç§å®žä¾‹å’Œä»Žä»¥å‰çš„ session 中装载过（可能又做过修改--译者注）但未再次持久化的实例区分开来。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate should use for accessing the property "
-"value."
-msgstr ""
-"<literal>access</literal>（可选 — 默认为 <literal>property</literal>）："
-"Hibernate 用来访问属性值的策略。 "
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate should use for accessing the property value."
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If the <literal>name</literal> attribute is missing, it is assumed that the "
-"class has no identifier property."
+msgid "If the <literal>name</literal> attribute is missing, it is assumed that the class has no identifier property."
 msgstr "如果 <literal>name</literal> å±žæ€§ä¸å­˜åœ¨ï¼Œä¼šè®¤ä¸ºè¿™ä¸ªç±»æ²¡æœ‰æ ‡è¯†å±žæ€§ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>unsaved-value</literal> attribute is almost never needed in "
-"Hibernate3."
+msgid "The <literal>unsaved-value</literal> attribute is almost never needed in Hibernate3."
 msgstr "<literal>unsaved-value</literal> 属性在 Hibernate3 ä¸­å‡ ä¹Žä¸å†éœ€è¦ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"There is an alternative <literal>&lt;composite-id&gt;</literal> declaration "
-"that allows access to legacy data with composite keys. Its use is strongly "
-"discouraged for anything else."
-msgstr ""
-"还有一个另外的 <literal>&lt;composite-id&gt;</literal> 定义可以访问旧式的多主"
-"键数据。我们非常不鼓励使用这种方式。"
+msgid "There is an alternative <literal>&lt;composite-id&gt;</literal> declaration that allows access to legacy data with composite keys. Its use is strongly discouraged for anything else."
+msgstr "还有一个另外的 <literal>&lt;composite-id&gt;</literal> 定义可以访问旧式的多主键数据。我们非常不鼓励使用这种方式。"
 
 #. Tag: title
 #, no-c-format
@@ -768,134 +387,78 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The optional <literal>&lt;generator&gt;</literal> child element names a Java "
-"class used to generate unique identifiers for instances of the persistent "
-"class. If any parameters are required to configure or initialize the "
-"generator instance, they are passed using the <literal>&lt;param&gt;</"
-"literal> element."
-msgstr ""
-"可选的 <literal>&lt;generator&gt;</literal> å­å…ƒç´ æ˜¯ä¸€ä¸ª Java 类的名字，用来"
-"ä¸ºè¯¥æŒä¹…åŒ–ç±»çš„å®žä¾‹ç”Ÿæˆå”¯ä¸€çš„æ ‡è¯†ã€‚å¦‚æžœè¿™ä¸ªç”Ÿæˆå™¨å®žä¾‹éœ€è¦æŸäº›é…ç½®å€¼æˆ–è€…åˆå§‹åŒ–"
-"参数，用 <literal>&lt;param&gt;</literal> å…ƒç´ æ¥ä¼ é€’ã€‚"
+msgid "The optional <literal>&lt;generator&gt;</literal> child element names a Java class used to generate unique identifiers for instances of the persistent class. If any parameters are required to configure or initialize the generator instance, they are passed using the <literal>&lt;param&gt;</literal> element."
+msgstr "可选的 <literal>&lt;generator&gt;</literal> å­å…ƒç´ æ˜¯ä¸€ä¸ª Java ç±»çš„åå­—ï¼Œç”¨æ¥ä¸ºè¯¥æŒä¹…åŒ–ç±»çš„å®žä¾‹ç”Ÿæˆå”¯ä¸€çš„æ ‡è¯†ã€‚å¦‚æžœè¿™ä¸ªç”Ÿæˆå™¨å®žä¾‹éœ€è¦æŸäº›é…ç½®å€¼æˆ–è€…åˆå§‹åŒ–å‚æ•°ï¼Œç”¨ <literal>&lt;param&gt;</literal> å…ƒç´ æ¥ä¼ é€’ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"All generators implement the interface <literal>org.hibernate.id."
-"IdentifierGenerator</literal>. This is a very simple interface. Some "
-"applications can choose to provide their own specialized implementations, "
-"however, Hibernate provides a range of built-in implementations. The "
-"shortcut names for the built-in generators are as follows:"
-msgstr ""
-"所有的生成器都实现 <literal>org.hibernate.id.IdentifierGenerator</literal> 接"
-"口。这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当"
-"然，Hibernate 提供了很多内置的实现。下面是一些内置生成器的快捷名字：  "
+msgid "All generators implement the interface <literal>org.hibernate.id.IdentifierGenerator</literal>. This is a very simple interface. Some applications can choose to provide their own specialized implementations, however, Hibernate provides a range of built-in implementations. The shortcut names for the built-in generators are as follows:"
+msgstr "所有的生成器都实现 <literal>org.hibernate.id.IdentifierGenerator</literal> 接口。这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当然，Hibernate 提供了很多内置的实现。下面是一些内置生成器的快捷名字：  "
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>increment</literal>"
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>increment</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"generates identifiers of type <literal>long</literal>, <literal>short</"
-"literal> or <literal>int</literal> that are unique only when no other "
-"process is inserting data into the same table. <emphasis>Do not use in a "
-"cluster.</emphasis>"
-msgstr ""
-"用于为 <literal>long</literal>, <literal>short</literal> 或者 <literal>int</"
-"literal> 类型生成 å”¯ä¸€æ ‡è¯†ã€‚åªæœ‰åœ¨æ²¡æœ‰å…¶ä»–è¿›ç¨‹å¾€åŒä¸€å¼ è¡¨ä¸­æ’å…¥æ•°æ®æ—¶æ‰èƒ½ä½¿"
-"用。<emphasis>在集群下不要使用。</emphasis>"
+msgid "generates identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal> that are unique only when no other process is inserting data into the same table. <emphasis>Do not use in a cluster.</emphasis>"
+msgstr "用于为 <literal>long</literal>, <literal>short</literal> 或者 <literal>int</literal> 类型生成 å”¯ä¸€æ ‡è¯†ã€‚åªæœ‰åœ¨æ²¡æœ‰å…¶ä»–è¿›ç¨‹å¾€åŒä¸€å¼ è¡¨ä¸­æ’å…¥æ•°æ®æ—¶æ‰èƒ½ä½¿ç”¨ã€‚<emphasis>在集群下不要使用。</emphasis>"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>identity</literal>"
-msgstr "<literal>id-type</literal>ï¼šæ ‡è¯†ç¬¦ç±»åž‹"
+msgstr "<literal>identity</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"supports identity columns in DB2, MySQL, MS SQL Server, Sybase and "
-"HypersonicSQL. The returned identifier is of type <literal>long</literal>, "
-"<literal>short</literal> or <literal>int</literal>."
-msgstr ""
-"对 DB2，MySQL，MS SQL Server，Sybase å’Œ HypersonicSQL çš„å†…ç½®æ ‡è¯†å­—æ®µæä¾›æ”¯"
-"æŒã€‚è¿”å›žçš„æ ‡è¯†ç¬¦æ˜¯ <literal>long</literal>，<literal>short</literal> 或者 "
-"<literal>int</literal> 类型的。"
+msgid "supports identity columns in DB2, MySQL, MS SQL Server, Sybase and HypersonicSQL. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>."
+msgstr "对 DB2，MySQL，MS SQL Server，Sybase å’Œ HypersonicSQL çš„å†…ç½®æ ‡è¯†å­—æ®µæä¾›æ”¯æŒã€‚è¿”å›žçš„æ ‡è¯†ç¬¦æ˜¯ <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> 类型的。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>sequence</literal>"
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>sequence</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in "
-"Interbase. The returned identifier is of type <literal>long</literal>, "
-"<literal>short</literal> or <literal>int</literal>"
-msgstr ""
-"在 DB2，PostgreSQL，Oracle，SAP DB，McKoi 中使用序列（sequence）， 而在 "
-"Interbase 中使用生成器（generatorï¼‰ã€‚è¿”å›žçš„æ ‡è¯†ç¬¦æ˜¯ <literal>long</literal>，"
-"<literal>short</literal> 或者 <literal>int</literal> 类型的。"
+msgid "uses a sequence in DB2, PostgreSQL, Oracle, SAP DB, McKoi or a generator in Interbase. The returned identifier is of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>"
+msgstr "在 DB2，PostgreSQL，Oracle，SAP DB，McKoi 中使用序列（sequence）， 而在 Interbase 中使用生成器（generatorï¼‰ã€‚è¿”å›žçš„æ ‡è¯†ç¬¦æ˜¯ <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> 类型的。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hilo</literal>"
-msgstr "<literal>all（全部）</literal>：检查全部字段"
+msgstr "<literal>hilo</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"uses a hi/lo algorithm to efficiently generate identifiers of type "
-"<literal>long</literal>, <literal>short</literal> or <literal>int</literal>, "
-"given a table and column (by default <literal>hibernate_unique_key</literal> "
-"and <literal>next_hi</literal> respectively) as a source of hi values. The "
-"hi/lo algorithm generates identifiers that are unique only for a particular "
-"database."
-msgstr ""
-"使用一个高/低位算法高效的生成 <literal>long</literal>，<literal>short</"
-"literal> 或者 <literal>int</literal> ç±»åž‹çš„æ ‡è¯†ç¬¦ã€‚ç»™å®šä¸€ä¸ªè¡¨å’Œå­—æ®µï¼ˆé»˜è®¤åˆ†åˆ«"
-"是 <literal>hibernate_unique_key</literal> 和 <literal>next_hi</literal>）作"
-"为高位值的来源。高/ä½Žä½ç®—æ³•ç”Ÿæˆçš„æ ‡è¯†ç¬¦åªåœ¨ä¸€ä¸ªç‰¹å®šçš„æ•°æ®åº“ä¸­æ˜¯å”¯ä¸€çš„ã€‚"
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a table and column (by default <literal>hibernate_unique_key</literal> and <literal>next_hi</literal> respectively) as a source of hi values. The hi/lo algorithm generates identifiers that are unique only for a particular database."
+msgstr "使用一个高/低位算法高效的生成 <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> ç±»åž‹çš„æ ‡è¯†ç¬¦ã€‚ç»™å®šä¸€ä¸ªè¡¨å’Œå­—æ®µï¼ˆé»˜è®¤åˆ†åˆ«æ˜¯ <literal>hibernate_unique_key</literal> å’Œ <literal>next_hi</literal>）作为高位值的来源。高/ä½Žä½ç®—æ³•ç”Ÿæˆçš„æ ‡è¯†ç¬¦åªåœ¨ä¸€ä¸ªç‰¹å®šçš„æ•°æ®åº“ä¸­æ˜¯å”¯ä¸€çš„ã€‚"
 
 #. Tag: term
 #, no-c-format
 msgid "<literal>seqhilo</literal>"
-msgstr ""
+msgstr "<literal>seqhilo</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"uses a hi/lo algorithm to efficiently generate identifiers of type "
-"<literal>long</literal>, <literal>short</literal> or <literal>int</literal>, "
-"given a named database sequence."
-msgstr ""
-"使用一个高/低位算法来高效的生成 <literal>long</literal>，<literal>short</"
-"literal> 或者 <literal>int</literal> ç±»åž‹çš„æ ‡è¯†ç¬¦ï¼Œç»™å®šä¸€ä¸ªæ•°æ®åº“åºåˆ—"
-"（sequence)的名字。"
+msgid "uses a hi/lo algorithm to efficiently generate identifiers of type <literal>long</literal>, <literal>short</literal> or <literal>int</literal>, given a named database sequence."
+msgstr "使用一个高/低位算法来高效的生成 <literal>long</literal>，<literal>short</literal> 或者 <literal>int</literal> ç±»åž‹çš„æ ‡è¯†ç¬¦ï¼Œç»™å®šä¸€ä¸ªæ•°æ®åº“åºåˆ—ï¼ˆsequence)的名字。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>uuid</literal>"
-msgstr "<title>id</title>"
+msgstr "<literal>uuid</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"uses a 128-bit UUID algorithm to generate identifiers of type string that "
-"are unique within a network (the IP address is used). The UUID is encoded as "
-"a string of 32 hexadecimal digits in length."
-msgstr ""
-"用一个 128-bit çš„ UUID ç®—æ³•ç”Ÿæˆå­—ç¬¦ä¸²ç±»åž‹çš„æ ‡è¯†ç¬¦ï¼Œè¿™åœ¨ä¸€ä¸ªç½‘ç»œä¸­æ˜¯å”¯ä¸€çš„ï¼ˆä½¿"
-"用了 IP 地址）。UUID è¢«ç¼–ç ä¸ºä¸€ä¸ª 32 位 16 进制数字的字符串。 "
+msgid "uses a 128-bit UUID algorithm to generate identifiers of type string that are unique within a network (the IP address is used). The UUID is encoded as a string of 32 hexadecimal digits in length."
+msgstr "用一个 128-bit çš„ UUID ç®—æ³•ç”Ÿæˆå­—ç¬¦ä¸²ç±»åž‹çš„æ ‡è¯†ç¬¦ï¼Œè¿™åœ¨ä¸€ä¸ªç½‘ç»œä¸­æ˜¯å”¯ä¸€çš„ï¼ˆä½¿ç”¨äº† IP 地址）。UUID è¢«ç¼–ç ä¸ºä¸€ä¸ª 32 位 16 进制数字的字符串。 "
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>guid</literal>"
-msgstr "<title>id</title>"
+msgstr "<literal>guid</literal>"
 
 #. Tag: para
 #, no-c-format
@@ -903,81 +466,54 @@
 msgstr "在 MS SQL Server 和 MySQL 中使用数据库生成的 GUID 字符串。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>native</literal>"
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>native</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"selects <literal>identity</literal>, <literal>sequence</literal> or "
-"<literal>hilo</literal> depending upon the capabilities of the underlying "
-"database."
-msgstr ""
-"æ ¹æ®åº•å±‚æ•°æ®åº“çš„èƒ½åŠ›é€‰æ‹© <literal>identity</literal>、<literal>sequence</"
-"literal> 或者 <literal>hilo</literal> 中的一个。"
+msgid "selects <literal>identity</literal>, <literal>sequence</literal> or <literal>hilo</literal> depending upon the capabilities of the underlying database."
+msgstr "æ ¹æ®åº•å±‚æ•°æ®åº“çš„èƒ½åŠ›é€‰æ‹© <literal>identity</literal>、<literal>sequence</literal> 或者 <literal>hilo</literal> 中的一个。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>assigned</literal>"
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>assigned</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"lets the application assign an identifier to the object before <literal>save"
-"()</literal> is called. This is the default strategy if no <literal>&lt;"
-"generator&gt;</literal> element is specified."
-msgstr ""
-"让应用程序在调用 <literal>save()</literal> ä¹‹å‰ä¸ºå¯¹è±¡åˆ†é…ä¸€ä¸ªæ ‡è¯†ç¬¦ã€‚è¿™æ˜¯ "
-"<literal>&lt;generator&gt;</literal> å…ƒç´ æ²¡æœ‰æŒ‡å®šæ—¶çš„é»˜è®¤ç”Ÿæˆç­–ç•¥ã€‚"
+msgid "lets the application assign an identifier to the object before <literal>save()</literal> is called. This is the default strategy if no <literal>&lt;generator&gt;</literal> element is specified."
+msgstr "让应用程序在调用 <literal>save()</literal> ä¹‹å‰ä¸ºå¯¹è±¡åˆ†é…ä¸€ä¸ªæ ‡è¯†ç¬¦ã€‚è¿™æ˜¯ <literal>&lt;generator&gt;</literal> å…ƒç´ æ²¡æœ‰æŒ‡å®šæ—¶çš„é»˜è®¤ç”Ÿæˆç­–ç•¥ã€‚"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>select</literal>"
-msgstr "<literal>all（全部）</literal>：检查全部字段"
+msgstr "<literal>select</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"retrieves a primary key, assigned by a database trigger, by selecting the "
-"row by some unique key and retrieving the primary key value."
+msgid "retrieves a primary key, assigned by a database trigger, by selecting the row by some unique key and retrieving the primary key value."
 msgstr "通过数据库触发器选择一些唯一主键的行并返回主键值来分配一个主键。 "
 
 #. Tag: term
 #, no-c-format
 msgid "<literal>foreign</literal>"
-msgstr ""
+msgstr "<literal>foreign</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"uses the identifier of another associated object. It is usually used in "
-"conjunction with a <literal>&lt;one-to-one&gt;</literal> primary key "
-"association."
-msgstr ""
-"ä½¿ç”¨å¦å¤–ä¸€ä¸ªç›¸å…³è”çš„å¯¹è±¡çš„æ ‡è¯†ç¬¦ã€‚å®ƒé€šå¸¸å’Œ <literal>&lt;one-to-one&gt;</"
-"literal> 联合起来使用。"
+msgid "uses the identifier of another associated object. It is usually used in conjunction with a <literal>&lt;one-to-one&gt;</literal> primary key association."
+msgstr "ä½¿ç”¨å¦å¤–ä¸€ä¸ªç›¸å…³è”çš„å¯¹è±¡çš„æ ‡è¯†ç¬¦ã€‚å®ƒé€šå¸¸å’Œ <literal>&lt;one-to-one&gt;</literal> 联合起来使用。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>sequence-identity</literal>"
-msgstr "sequence-identity"
+msgstr "<literal>sequence-identity</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"a specialized sequence generation strategy that utilizes a database sequence "
-"for the actual value generation, but combines this with JDBC3 "
-"getGeneratedKeys to return the generated identifier value as part of the "
-"insert statement execution. This strategy is only supported on Oracle 10g "
-"drivers targeted for JDK 1.4. Comments on these insert statements are "
-"disabled due to a bug in the Oracle drivers."
-msgstr ""
-"一种特别的序列生成策略，它使用数据库序列来生成实际值，但将它和 JDBC3 的 "
-"getGeneratedKeys 结合在一起，使得在插入语句执行的时候就返回生成的值。目前为止"
-"只有面向 JDK 1.4 的 Oracle 10g 驱动支持这一策略。由于 Oracle 驱动程序的一个 "
-"bug，这些插入语句的注释被关闭了。"
+msgid "a specialized sequence generation strategy that utilizes a database sequence for the actual value generation, but combines this with JDBC3 getGeneratedKeys to return the generated identifier value as part of the insert statement execution. This strategy is only supported on Oracle 10g drivers targeted for JDK 1.4. Comments on these insert statements are disabled due to a bug in the Oracle drivers."
+msgstr "一种特别的序列生成策略，它使用数据库序列来生成实际值，但将它和 JDBC3 的 getGeneratedKeys 结合在一起，使得在插入语句执行的时候就返回生成的值。目前为止只有面向 JDK 1.4 的 Oracle 10g 驱动支持这一策略。由于 Oracle 驱动程序的一个 bug，这些插入语句的注释被关闭了。"
 
 #. Tag: title
 #, no-c-format
@@ -986,31 +522,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>hilo</literal> and <literal>seqhilo</literal> generators "
-"provide two alternate implementations of the hi/lo algorithm. The first "
-"implementation requires a \"special\" database table to hold the next "
-"available \"hi\" value. Where supported, the second uses an Oracle-style "
-"sequence."
-msgstr ""
-"<literal>hilo</literal> 和 <literal>seqhilo</literal> 生成器给出了两种 hi/lo "
-"算法的实现， è¿™æ˜¯ä¸€ç§å¾ˆä»¤äººæ»¡æ„çš„æ ‡è¯†ç¬¦ç”Ÿæˆç®—æ³•ã€‚ç¬¬ä¸€ç§å®žçŽ°éœ€è¦ä¸€ä¸ªâ€œç‰¹æ®Šâ€çš„æ•°"
-"据库表来保存下一个可用的“hi”值。 第二种实现使用一个 Oracle é£Žæ ¼çš„åºåˆ—ï¼ˆåœ¨è¢«æ”¯"
-"持的情况下）。 "
+msgid "The <literal>hilo</literal> and <literal>seqhilo</literal> generators provide two alternate implementations of the hi/lo algorithm. The first implementation requires a \"special\" database table to hold the next available \"hi\" value. Where supported, the second uses an Oracle-style sequence."
+msgstr "<literal>hilo</literal> å’Œ <literal>seqhilo</literal> 生成器给出了两种 hi/lo 算法的实现， è¿™æ˜¯ä¸€ç§å¾ˆä»¤äººæ»¡æ„çš„æ ‡è¯†ç¬¦ç”Ÿæˆç®—æ³•ã€‚ç¬¬ä¸€ç§å®žçŽ°éœ€è¦ä¸€ä¸ªâ€œç‰¹æ®Šâ€çš„æ•°æ®åº“è¡¨æ¥ä¿å­˜ä¸‹ä¸€ä¸ªå¯ç”¨çš„â€œhi”值。 第二种实现使用一个 Oracle é£Žæ ¼çš„åºåˆ—ï¼ˆåœ¨è¢«æ”¯æŒçš„æƒ…å†µä¸‹ï¼‰ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Unfortunately, you cannot use <literal>hilo</literal> when supplying your "
-"own <literal>Connection</literal> to Hibernate. When Hibernate uses an "
-"application server datasource to obtain connections enlisted with JTA, you "
-"must configure the <literal>hibernate.transaction.manager_lookup_class</"
-"literal>."
-msgstr ""
-"å¯æƒœçš„æ˜¯ï¼Œä½ åœ¨ä¸º Hibernate 自行提供 <literal>Connection</literal> æ—¶æ— æ³•ä½¿ç”¨ "
-"<literal>hilo</literal>。 当 Hibernate 使用 JTA 获取应用服务器的数据源连接"
-"æ—¶ï¼Œä½ å¿…é¡»æ­£ç¡®åœ°é…ç½® <literal>hibernate.transaction.manager_lookup_class</"
-"literal>。"
+msgid "Unfortunately, you cannot use <literal>hilo</literal> when supplying your own <literal>Connection</literal> to Hibernate. When Hibernate uses an application server datasource to obtain connections enlisted with JTA, you must configure the <literal>hibernate.transaction.manager_lookup_class</literal>."
+msgstr "å¯æƒœçš„æ˜¯ï¼Œä½ åœ¨ä¸º Hibernate 自行提供 <literal>Connection</literal> æ—¶æ— æ³•ä½¿ç”¨ <literal>hilo</literal>。 当 Hibernate 使用 JTA èŽ·å–åº”ç”¨æœåŠ¡å™¨çš„æ•°æ®æºè¿žæŽ¥æ—¶ï¼Œä½ å¿…é¡»æ­£ç¡®åœ°é…ç½® <literal>hibernate.transaction.manager_lookup_class</literal>。"
 
 #. Tag: title
 #, no-c-format
@@ -1019,15 +537,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The UUID contains: IP address, startup time of the JVM that is accurate to a "
-"quarter second, system time and a counter value that is unique within the "
-"JVM. It is not possible to obtain a MAC address or memory address from Java "
-"code, so this is the best option without using JNI."
-msgstr ""
-"UUID 包含：IP 地址、JVM 的启动时间（精确到 1/4 秒）、系统时间和一个计数器值"
-"（在 JVM 中唯一）。 在 Java ä»£ç ä¸­ä¸å¯èƒ½èŽ·å¾— MAC 地址或者内存地址，所以这已经"
-"是我们在不使用 JNI 的前提下的能做的最好实现了。"
+msgid "The UUID contains: IP address, startup time of the JVM that is accurate to a quarter second, system time and a counter value that is unique within the JVM. It is not possible to obtain a MAC address or memory address from Java code, so this is the best option without using JNI."
+msgstr "UUID 包含：IP 地址、JVM 的启动时间（精确到 1/4 秒）、系统时间和一个计数器值（在 JVM 中唯一）。 在 Java ä»£ç ä¸­ä¸å¯èƒ½èŽ·å¾— MAC 地址或者内存地址，所以这已经是我们在不使用 JNI 的前提下的能做的最好实现了。"
 
 #. Tag: title
 #, no-c-format
@@ -1036,30 +547,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For databases that support identity columns (DB2, MySQL, Sybase, MS SQL), "
-"you can use <literal>identity</literal> key generation. For databases that "
-"support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you "
-"can use <literal>sequence</literal> style key generation. Both of these "
-"strategies require two SQL queries to insert a new object. For example:"
-msgstr ""
-"å¯¹äºŽå†…éƒ¨æ”¯æŒæ ‡è¯†å­—æ®µçš„æ•°æ®åº“ï¼ˆDB2、MySQL、Sybase å’Œ MS SQLï¼‰ï¼Œä½ å¯ä»¥ä½¿ç”¨ "
-"<literal>identity</literal> 关键字生成。对于内部支持序列的数据库（DB2、"
-"Oracle、PostgreSQL、Interbase、McKoi å’Œ SAP DBï¼‰ï¼Œä½ å¯ä»¥ä½¿ç”¨ "
-"<literal>sequence</literal> é£Žæ ¼çš„å…³é”®å­—ç”Ÿæˆã€‚è¿™ä¸¤ç§æ–¹å¼å¯¹äºŽæ’å…¥ä¸€ä¸ªæ–°çš„å¯¹è±¡"
-"都需要两次 SQL 查询。例如："
+msgid "For databases that support identity columns (DB2, MySQL, Sybase, MS SQL), you can use <literal>identity</literal> key generation. For databases that support sequences (DB2, Oracle, PostgreSQL, Interbase, McKoi, SAP DB) you can use <literal>sequence</literal> style key generation. Both of these strategies require two SQL queries to insert a new object. For example:"
+msgstr "å¯¹äºŽå†…éƒ¨æ”¯æŒæ ‡è¯†å­—æ®µçš„æ•°æ®åº“ï¼ˆDB2、MySQL、Sybase å’Œ MS SQLï¼‰ï¼Œä½ å¯ä»¥ä½¿ç”¨ <literal>identity</literal> 关键字生成。对于内部支持序列的数据库（DB2、Oracle、PostgreSQL、Interbase、McKoi å’Œ SAP DBï¼‰ï¼Œä½ å¯ä»¥ä½¿ç”¨ <literal>sequence</literal> é£Žæ ¼çš„å…³é”®å­—ç”Ÿæˆã€‚è¿™ä¸¤ç§æ–¹å¼å¯¹äºŽæ’å…¥ä¸€ä¸ªæ–°çš„å¯¹è±¡éƒ½éœ€è¦ä¸¤æ¬¡ SQL 查询。例如："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For cross-platform development, the <literal>native</literal> strategy will, "
-"depending on the capabilities of the underlying database, choose from the "
-"<literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</"
-"literal> strategies."
-msgstr ""
-"对于跨平台开发，<literal>native</literal> 策略会从 <literal>identity</"
-"literal>、<literal>sequence</literal> 和 <literal>hilo</literal> 中进行选择，"
-"选择哪一个，这取决于底层数据库的支持能力。"
+msgid "For cross-platform development, the <literal>native</literal> strategy will, depending on the capabilities of the underlying database, choose from the <literal>identity</literal>, <literal>sequence</literal> and <literal>hilo</literal> strategies."
+msgstr "对于跨平台开发，<literal>native</literal> 策略会从 <literal>identity</literal>、<literal>sequence</literal> 和 <literal>hilo</literal> 中进行选择，选择哪一个，这取决于底层数据库的支持能力。"
 
 #. Tag: title
 #, no-c-format
@@ -1068,35 +562,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you want the application to assign identifiers, as opposed to having "
-"Hibernate generate them, you can use the <literal>assigned</literal> "
-"generator. This special generator uses the identifier value already assigned "
-"to the object's identifier property. The generator is used when the primary "
-"key is a natural key instead of a surrogate key. This is the default "
-"behavior if you do not specify a <literal>&lt;generator&gt;</literal> "
-"element."
-msgstr ""
-"å¦‚æžœä½ éœ€è¦åº”ç”¨ç¨‹åºåˆ†é…ä¸€ä¸ªæ ‡ç¤ºç¬¦ï¼ˆè€Œéž Hibernate æ¥ç”Ÿæˆï¼‰ï¼Œä½ å¯ä»¥ä½¿ç”¨ "
-"<literal>assigned</literal> ç”Ÿæˆå™¨ã€‚è¿™ç§ç‰¹æ®Šçš„ç”Ÿæˆå™¨ä¼šä½¿ç”¨å·²ç»åˆ†é…ç»™å¯¹è±¡çš„æ ‡"
-"è¯†ç¬¦å±žæ€§çš„æ ‡è¯†ç¬¦å€¼ã€‚ 这个生成器使用一个自然键（natural key，有商业意义的列－"
-"译注）作为主键，而不是使用一个代理键（ surrogate key，没有商业意义的列－译"
-"注）。这是没有指定 <literal>&lt;generator&gt;</literal> å…ƒç´ æ—¶çš„é»˜è®¤è¡Œä¸ºã€‚"
+msgid "If you want the application to assign identifiers, as opposed to having Hibernate generate them, you can use the <literal>assigned</literal> generator. This special generator uses the identifier value already assigned to the object's identifier property. The generator is used when the primary key is a natural key instead of a surrogate key. This is the default behavior if you do not specify a <literal>&lt;generator&gt;</literal> element."
+msgstr "å¦‚æžœä½ éœ€è¦åº”ç”¨ç¨‹åºåˆ†é…ä¸€ä¸ªæ ‡ç¤ºç¬¦ï¼ˆè€Œéž Hibernate æ¥ç”Ÿæˆï¼‰ï¼Œä½ å¯ä»¥ä½¿ç”¨ <literal>assigned</literal> ç”Ÿæˆå™¨ã€‚è¿™ç§ç‰¹æ®Šçš„ç”Ÿæˆå™¨ä¼šä½¿ç”¨å·²ç»åˆ†é…ç»™å¯¹è±¡çš„æ ‡è¯†ç¬¦å±žæ€§çš„æ ‡è¯†ç¬¦å€¼ã€‚ 这个生成器使用一个自然键（natural key，有商业意义的列－译注）作为主键，而不是使用一个代理键（ surrogate key，没有商业意义的列－译注）。这是没有指定 <literal>&lt;generator&gt;</literal> å…ƒç´ æ—¶çš„é»˜è®¤è¡Œä¸ºã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>assigned</literal> generator makes Hibernate use "
-"<literal>unsaved-value=\"undefined\"</literal>. This forces Hibernate to go "
-"to the database to determine if an instance is transient or detached, unless "
-"there is a version or timestamp property, or you define <literal>Interceptor."
-"isUnsaved()</literal>."
-msgstr ""
-"当选择 <literal>assigned</literal> 生成器时，除非有一个 version 或 timestamp "
-"å±žæ€§ï¼Œæˆ–è€…ä½ å®šä¹‰äº† <literal>Interceptor.isUnsaved()</literal>，否则需要让 "
-"Hiberante 使用 <literal>unsaved-value=\"undefined\"</literal>，强制 "
-"Hibernatet 查询数据库来确定一个实例是瞬时的（transient） 还是脱管的"
-"（detached）。"
+msgid "The <literal>assigned</literal> generator makes Hibernate use <literal>unsaved-value=\"undefined\"</literal>. This forces Hibernate to go to the database to determine if an instance is transient or detached, unless there is a version or timestamp property, or you define <literal>Interceptor.isUnsaved()</literal>."
+msgstr "当选择 <literal>assigned</literal> 生成器时，除非有一个 version 或 timestamp å±žæ€§ï¼Œæˆ–è€…ä½ å®šä¹‰äº† <literal>Interceptor.isUnsaved()</literal>，否则需要让 Hiberante 使用 <literal>unsaved-value=\"undefined\"</literal>，强制 Hibernatet 查询数据库来确定一个实例是瞬时的（transient） 还是脱管的（detached）。"
 
 #. Tag: title
 #, no-c-format
@@ -1105,21 +577,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate does not generate DDL with triggers. It is for legacy schemas only."
+msgid "Hibernate does not generate DDL with triggers. It is for legacy schemas only."
 msgstr "仅仅用于遗留的 schema 中（Hibernate 不能用触发器生成 DDL）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In the above example, there is a unique valued property named "
-"<literal>socialSecurityNumber</literal>. It is defined by the class, as a "
-"natural key and a surrogate key named <literal>person_id</literal>, whose "
-"value is generated by a trigger."
-msgstr ""
-"在上面的例子中，类定义了一个命名为 <literal>socialSecurityNumber</literal> 的"
-"具有唯一值的属性，它是一个自然键（natural key），命名为 <literal>person_id</"
-"literal> 的代理键（surrogate key）的值由触发器生成。"
+msgid "In the above example, there is a unique valued property named <literal>socialSecurityNumber</literal>. It is defined by the class, as a natural key and a surrogate key named <literal>person_id</literal>, whose value is generated by a trigger."
+msgstr "在上面的例子中，类定义了一个命名为 <literal>socialSecurityNumber</literal> 的具有唯一值的属性，它是一个自然键（natural key），命名为 <literal>person_id</literal> 的代理键（surrogate key）的值由触发器生成。"
 
 #. Tag: title
 #, no-c-format
@@ -1128,208 +592,88 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Starting with release 3.2.3, there are 2 new generators which represent a re-"
-"thinking of 2 different aspects of identifier generation. The first aspect "
-"is database portability; the second is optimization Optimization means that "
-"you do not have to query the database for every request for a new identifier "
-"value. These two new generators are intended to take the place of some of "
-"the named generators described above, starting in 3.3.x. However, they are "
-"included in the current releases and can be referenced by FQN."
-msgstr ""
-"从 3.2.3 ç‰ˆæœ¬å¼€å§‹ï¼Œæœ‰ä¸¤ä¸ªä»£è¡¨ä¸åŒæ ‡è¯†ç¬¦ç”Ÿæˆæ¦‚å¿µçš„æ–°çš„ç”Ÿæˆå™¨ã€‚ç¬¬ä¸€ä¸ªæ¦‚å¿µæ˜¯æ•°æ®"
-"åº“ç§»æ¤æ€§ï¼›ç¬¬äºŒä¸ªæ˜¯ä¼˜åŒ–ã€‚ä¼˜åŒ–è¡¨ç¤ºä½ ä¸éœ€å¯¹æ¯ä¸ªæ–°æ ‡è¯†ç¬¦çš„è¯·æ±‚éƒ½æŸ¥è¯¢æ•°æ®åº“ã€‚ä»Ž "
-"3.3.x 开始，这两个新的生成器都是用来取代上面所述的生成器的。然而，它们也包括"
-"在当前版本里且可以由 FQN 进行引用。"
+msgid "Starting with release 3.2.3, there are 2 new generators which represent a re-thinking of 2 different aspects of identifier generation. The first aspect is database portability; the second is optimization Optimization means that you do not have to query the database for every request for a new identifier value. These two new generators are intended to take the place of some of the named generators described above, starting in 3.3.x. However, they are included in the current releases and can be referenced by FQN."
+msgstr "从 3.2.3 ç‰ˆæœ¬å¼€å§‹ï¼Œæœ‰ä¸¤ä¸ªä»£è¡¨ä¸åŒæ ‡è¯†ç¬¦ç”Ÿæˆæ¦‚å¿µçš„æ–°çš„ç”Ÿæˆå™¨ã€‚ç¬¬ä¸€ä¸ªæ¦‚å¿µæ˜¯æ•°æ®åº“ç§»æ¤æ€§ï¼›ç¬¬äºŒä¸ªæ˜¯ä¼˜åŒ–ã€‚ä¼˜åŒ–è¡¨ç¤ºä½ ä¸éœ€å¯¹æ¯ä¸ªæ–°æ ‡è¯†ç¬¦çš„è¯·æ±‚éƒ½æŸ¥è¯¢æ•°æ®åº“ã€‚ä»Ž 3.3.x 开始，这两个新的生成器都是用来取代上面所述的生成器的。然而，它们也包括在当前版本里且可以由 FQN 进行引用。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The first of these new generators is <literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal> which is intended, firstly, as a "
-"replacement for the <literal>sequence</literal> generator and, secondly, as "
-"a better portability generator than <literal>native</literal>. This is "
-"because <literal>native</literal> generally chooses between "
-"<literal>identity</literal> and <literal>sequence</literal> which have "
-"largely different semantics that can cause subtle issues in applications "
-"eyeing portability. <literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal>, however, achieves portability in a "
-"different manner. It chooses between a table or a sequence in the database "
-"to store its incrementing values, depending on the capabilities of the "
-"dialect being used. The difference between this and <literal>native</"
-"literal> is that table-based and sequence-based storage have the same exact "
-"semantic. In fact, sequences are exactly what Hibernate tries to emulate "
-"with its table-based generators. This generator has a number of "
-"configuration parameters:"
-msgstr ""
-"这些生成器的第一个是 <literal>org.hibernate.id.enhanced."
-"SequenceStyleGenerator</literal>，首先，它是作为 <literal>sequence</literal> "
-"生成器的替代物，其次，它是比 <literal>native</literal> 具有更好移植性的生成"
-"å™¨ã€‚è¿™æ˜¯å› ä¸º <literal>native</literal> 通常在 <literal>identity</literal> å’Œ "
-"<literal>sequence</literal> 之间选择，它有差别很大的 semantic，在移植时会导致"
-"潜在的问题。然而，<literal>org.hibernate.id.enhanced.SequenceStyleGenerator</"
-"literal> ä»¥ä¸åŒçš„æ–¹å¼å®žçŽ°ç§»æ¤æ€§ã€‚å®ƒæ ¹æ®æ‰€ä½¿ç”¨çš„æ–¹è¨€çš„èƒ½åŠ›ï¼Œåœ¨æ•°æ®åº“è¡¨æˆ–åºåˆ—ä¹‹"
-"间选择以存储其增量。这和 <literal>native</literal> 的区别是基于表或序列的存储"
-"具有恰好相同的 semantic。实际上，序列就是 Hibernate 试图用基于表的生成器来模"
-"拟的。这个生成器有如下的配置参数："
+msgid "The first of these new generators is <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> which is intended, firstly, as a replacement for the <literal>sequence</literal> generator and, secondly, as a better portability generator than <literal>native</literal>. This is because <literal>native</literal> generally chooses between <literal>identity</literal> and <literal>sequence</literal> which have largely different semantics that can cause subtle issues in applications eyeing portability. <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal>, however, achieves portability in a different manner. It chooses between a table or a sequence in the database to store its incrementing values, depending on the capabilities of the dialect being used. The difference between this and <literal>native</literal> is that table-based and sequence-based storage have the same exact semantic. In fact, sequences are exactly what Hibernate tries to emulate with!
  its table-based generators. This generator has a number of configuration parameters:"
+msgstr "这些生成器的第一个是 <literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal>，首先，它是作为 <literal>sequence</literal> 生成器的替代物，其次，它是比 <literal>native</literal> å…·æœ‰æ›´å¥½ç§»æ¤æ€§çš„ç”Ÿæˆå™¨ã€‚è¿™æ˜¯å› ä¸º <literal>native</literal> 通常在 <literal>identity</literal> å’Œ <literal>sequence</literal> 之间选择，它有差别很大的 semantic，在移植时会导致潜在的问题。然而，<literal>org.hibernate.id.enhanced.SequenceStyleGenerator</literal> ä»¥ä¸åŒçš„æ–¹å¼å®žçŽ°ç§»æ¤æ€§ã€‚å®ƒæ ¹æ®æ‰€ä½¿ç”¨çš„æ–¹è¨€çš„èƒ½åŠ›ï¼Œåœ¨æ•°æ®åº“è¡¨æˆ–åºåˆ—ä¹‹é—´é€‰æ‹©ä»¥å­˜å‚¨å…¶å¢žé‡ã€‚è¿™å’Œ <literal>native</literal> 的区别是基于表或序列的存储具有恰好相同的 semantic。实际上，序列就是 Hibernate 试图用基于表的生成器来模拟的。这个生成器有如下的配置参数："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>sequence_name</literal> (optional, defaults to "
-"<literal>hibernate_sequence</literal>): the name of the sequence or table to "
-"be used."
-msgstr ""
-"<literal>sequence_name</literal>（可选 — 默认为 <literal>hibernate_sequence</"
-"literal>）：序列或表的名字"
+msgid "<literal>sequence_name</literal> (optional, defaults to <literal>hibernate_sequence</literal>): the name of the sequence or table to be used."
+msgstr "<literal>sequence_name</literal>（可选 — 默认为 <literal>hibernate_sequence</literal>）：序列或表的名字"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>initial_value</literal> (optional, defaults to <literal>1</"
-"literal>): the initial value to be retrieved from the sequence/table. In "
-"sequence creation terms, this is analogous to the clause typically named "
-"\"STARTS WITH\"."
-msgstr ""
-"<literal>initial_value</literal>（可选，默认为 <literal>1</literal>）：从序"
-"列/表里获取的初始值。按照序列创建的术语，这等同于子句 \"STARTS WITH\"。"
+msgid "<literal>initial_value</literal> (optional, defaults to <literal>1</literal>): the initial value to be retrieved from the sequence/table. In sequence creation terms, this is analogous to the clause typically named \"STARTS WITH\"."
+msgstr "<literal>initial_value</literal>（可选，默认为 <literal>1</literal>）：从序列/表里获取的初始值。按照序列创建的术语，这等同于子句 \"STARTS WITH\"。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>increment_size</literal> (optional - defaults to <literal>1</"
-"literal>): the value by which subsequent calls to the sequence/table should "
-"differ. In sequence creation terms, this is analogous to the clause "
-"typically named \"INCREMENT BY\"."
-msgstr ""
-"<literal>increment_size</literal>（可选 - 缺省为 <literal>1</literal>）：对序"
-"列/表的调用应该区分的值。按照序列创建的术语，这等同于子句 \"INCREMENT BY\"。"
+msgid "<literal>increment_size</literal> (optional - defaults to <literal>1</literal>): the value by which subsequent calls to the sequence/table should differ. In sequence creation terms, this is analogous to the clause typically named \"INCREMENT BY\"."
+msgstr "<literal>increment_size</literal>（可选 - 缺省为 <literal>1</literal>）：对序列/表的调用应该区分的值。按照序列创建的术语，这等同于子句 \"INCREMENT BY\"。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>force_table_use</literal> (optional - defaults to <literal>false</"
-"literal>): should we force the use of a table as the backing structure even "
-"though the dialect might support sequence?"
-msgstr ""
-"<literal>force_table_use</literal>（可选 - 缺省为 <literal>false</"
-"literal>）：即使方言可能支持序列，是否也应该强制把表用作后台结构。"
+msgid "<literal>force_table_use</literal> (optional - defaults to <literal>false</literal>): should we force the use of a table as the backing structure even though the dialect might support sequence?"
+msgstr "<literal>force_table_use</literal>（可选 - 缺省为 <literal>false</literal>）：即使方言可能支持序列，是否也应该强制把表用作后台结构。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>value_column</literal> (optional - defaults to <literal>next_val</"
-"literal>): only relevant for table structures, it is the name of the column "
-"on the table which is used to hold the value."
-msgstr ""
-"<literal>value_column</literal>（可选 - 缺省为 <literal>next_val</"
-"literal>）：只和表结构相关，它是用于保存值的字段的名称。"
+msgid "<literal>value_column</literal> (optional - defaults to <literal>next_val</literal>): only relevant for table structures, it is the name of the column on the table which is used to hold the value."
+msgstr "<literal>value_column</literal>（可选 - 缺省为 <literal>next_val</literal>）：只和表结构相关，它是用于保存值的字段的名称。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optimizer</literal> (optional - defaults to <literal>none</"
-"literal>): See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" /"
-">"
-msgstr "<literal>optimizer</literal>（可选 — 默认是<literal>none</literal>）："
+#, no-c-format
+msgid "<literal>optimizer</literal> (optional - defaults to <literal>none</literal>): See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" />"
+msgstr "<literal>optimizer</literal>（可选 — 默认是<literal>none</literal>）：请参考 <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" />。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The second of these new generators is <literal>org.hibernate.id.enhanced."
-"TableGenerator</literal>, which is intended, firstly, as a replacement for "
-"the <literal>table</literal> generator, even though it actually functions "
-"much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</"
-"literal>, and secondly, as a re-implementation of <literal>org.hibernate.id."
-"MultipleHiLoPerTableGenerator</literal> that utilizes the notion of "
-"pluggable optimizers. Essentially this generator defines a table capable of "
-"holding a number of different increment values simultaneously by using "
-"multiple distinctly keyed rows. This generator has a number of configuration "
-"parameters:"
-msgstr ""
-"新生成器的第二个是 <literal>org.hibernate.id.enhanced.TableGenerator</"
-"literal>，它的目的首先是替代 <literal>table</literal> 生成器，即使它实际上比 "
-"<literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> 功能要强得"
-"多；其次，作为利用可插拔 optimizer 的 <literal>org.hibernate.id."
-"MultipleHiLoPerTableGenerator</literal> 的替代品。基本上这个生成器定义了一个"
-"可以利用多个不同的键值记录存储大量不同增量值的表。这个生成器有如下的配置参"
-"数："
+msgid "The second of these new generators is <literal>org.hibernate.id.enhanced.TableGenerator</literal>, which is intended, firstly, as a replacement for the <literal>table</literal> generator, even though it actually functions much more like <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal>, and secondly, as a re-implementation of <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> that utilizes the notion of pluggable optimizers. Essentially this generator defines a table capable of holding a number of different increment values simultaneously by using multiple distinctly keyed rows. This generator has a number of configuration parameters:"
+msgstr "新生成器的第二个是 <literal>org.hibernate.id.enhanced.TableGenerator</literal>，它的目的首先是替代 <literal>table</literal> 生成器，即使它实际上比 <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> 功能要强得多；其次，作为利用可插拔 optimizer 的 <literal>org.hibernate.id.MultipleHiLoPerTableGenerator</literal> 的替代品。基本上这个生成器定义了一个可以利用多个不同的键值记录存储大量不同增量值的表。这个生成器有如下的配置参数："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>table_name</literal> (optional - defaults to "
-"<literal>hibernate_sequences</literal>): the name of the table to be used."
-msgstr ""
-"<literal>table_name</literal>（可选 — 默认是 <literal>hibernate_sequences</"
-"literal>）：所用的表的名称。"
+msgid "<literal>table_name</literal> (optional - defaults to <literal>hibernate_sequences</literal>): the name of the table to be used."
+msgstr "<literal>table_name</literal>（可选 — 默认是 <literal>hibernate_sequences</literal>）：所用的表的名称。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>value_column_name</literal> (optional - defaults to "
-"<literal>next_val</literal>): the name of the column on the table that is "
-"used to hold the value."
-msgstr ""
-"<literal>value_column_name</literal>（可选 — 默认为 <literal>next_val</"
-"literal>）：用于存储这些值的表的字段的名字。"
+msgid "<literal>value_column_name</literal> (optional - defaults to <literal>next_val</literal>): the name of the column on the table that is used to hold the value."
+msgstr "<literal>value_column_name</literal>（可选 — 默认为 <literal>next_val</literal>）：用于存储这些值的表的字段的名字。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>segment_column_name</literal> (optional - defaults to "
-"<literal>sequence_name</literal>): the name of the column on the table that "
-"is used to hold the \"segment key\". This is the value which identifies "
-"which increment value to use."
-msgstr ""
-"<literal>segment_column_name</literal>（可选，默认为 <literal>sequence_name</"
-"literal>）：用于保存 \"segment key\" çš„å­—æ®µçš„åç§°ã€‚è¿™æ˜¯æ ‡è¯†ä½¿ç”¨å“ªä¸ªå¢žé‡å€¼çš„"
-"值。"
+msgid "<literal>segment_column_name</literal> (optional - defaults to <literal>sequence_name</literal>): the name of the column on the table that is used to hold the \"segment key\". This is the value which identifies which increment value to use."
+msgstr "<literal>segment_column_name</literal>（可选，默认为 <literal>sequence_name</literal>）：用于保存 \"segment key\" çš„å­—æ®µçš„åç§°ã€‚è¿™æ˜¯æ ‡è¯†ä½¿ç”¨å“ªä¸ªå¢žé‡å€¼çš„å€¼ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>segment_value</literal> (optional - defaults to <literal>default</"
-"literal>): The \"segment key\" value for the segment from which we want to "
-"pull increment values for this generator."
-msgstr ""
-"<literal>segment_value</literal>（可选，默认为 <literal>default</literal>）："
-"我们为这个生成器获取增量值的 segment 的 \"segment key\"。"
+msgid "<literal>segment_value</literal> (optional - defaults to <literal>default</literal>): The \"segment key\" value for the segment from which we want to pull increment values for this generator."
+msgstr "<literal>segment_value</literal>（可选，默认为 <literal>default</literal>）：我们为这个生成器获取增量值的 segment 的 \"segment key\"。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>segment_value_length</literal> (optional - defaults to "
-"<literal>255</literal>): Used for schema generation; the column size to "
-"create this segment key column."
-msgstr ""
-"<literal>segment_value_length</literal>（可选 — 默认为 <literal>255</"
-"literal>）：用于 schema 生成；创建 Segment Key 字段的字段大小。"
+msgid "<literal>segment_value_length</literal> (optional - defaults to <literal>255</literal>): Used for schema generation; the column size to create this segment key column."
+msgstr "<literal>segment_value_length</literal>（可选 — 默认为 <literal>255</literal>）：用于 schema 生成；创建 Segment Key 字段的字段大小。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>initial_value</literal> (optional - defaults to <literal>1</"
-"literal>): The initial value to be retrieved from the table."
-msgstr ""
-"<literal>initial_value</literal>（可选 — 默认是 <literal>1</literal>）：从表"
-"里获取的初始值。"
+msgid "<literal>initial_value</literal> (optional - defaults to <literal>1</literal>): The initial value to be retrieved from the table."
+msgstr "<literal>initial_value</literal>（可选 — 默认是 <literal>1</literal>）：从表里获取的初始值。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>increment_size</literal> (optional - defaults to <literal>1</"
-"literal>): The value by which subsequent calls to the table should differ."
-msgstr ""
-"<literal>increment_size</literal>（可选 — 默认是 <literal>1</literal>）：对表"
-"随后的调用应该区分的值。"
+msgid "<literal>increment_size</literal> (optional - defaults to <literal>1</literal>): The value by which subsequent calls to the table should differ."
+msgstr "<literal>increment_size</literal>（可选 — 默认是 <literal>1</literal>）：对表随后的调用应该区分的值。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optimizer</literal> (optional - defaults to <literal></literal>): "
-"See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" />"
-msgstr "<literal>optimizer</literal>（可选 — 默认是 <literal> </literal>）："
+#, no-c-format
+msgid "<literal>optimizer</literal> (optional - defaults to <literal></literal>): See <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" />"
+msgstr "<literal>optimizer</literal>（可选 — 默认是 <literal> </literal>）：请参考 <xref linkend=\"mapping-declaration-id-enhanced-optimizers\" />。"
 
 #. Tag: title
 #, no-c-format
@@ -1337,59 +681,24 @@
 msgstr "æ ‡è¯†ç¬¦ç”Ÿæˆå™¨çš„ä¼˜åŒ–"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For identifier generators that store values in the database, it is "
-"inefficient for them to hit the database on each and every call to generate "
-"a new identifier value. Instead, you can group a bunch of them in memory and "
-"only hit the database when you have exhausted your in-memory value group. "
-"This is the role of the pluggable optimizers. Currently only the two "
-"enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\" /> "
-"support this operation."
-msgstr ""
-"å¯¹äºŽåœ¨æ•°æ®åº“é‡Œå­˜å‚¨å€¼çš„æ ‡è¯†ç¬¦ç”Ÿæˆå™¨ï¼Œç”Ÿæˆæ–°æ ‡è¯†ç¬¦æ—¶çš„æ¯æ¬¡è°ƒç”¨éƒ½è®¿é—®æ•°æ®åº“æ˜¯ä½Ž"
-"æ•ˆçš„ã€‚å› æ­¤ï¼Œä½ å¯ä»¥æŠŠå®ƒä»¬åœ¨å†…å­˜é‡Œåˆ†ç»„å¹¶åªæœ‰åœ¨å¿«ç”¨å…‰å†…å­˜æ—¶æ‰è®¿é—®æ•°æ®åº“ã€‚è¿™æ˜¯å¯"
-"插拔 optimizer 的任务。目前只有两个增强型的生成器支持这个操作（<xref linkend="
-"\"mapping-declaration-id-enhanced\"/>）。"
+#, no-c-format
+msgid "For identifier generators that store values in the database, it is inefficient for them to hit the database on each and every call to generate a new identifier value. Instead, you can group a bunch of them in memory and only hit the database when you have exhausted your in-memory value group. This is the role of the pluggable optimizers. Currently only the two enhanced generators (<xref linkend=\"mapping-declaration-id-enhanced\" /> support this operation."
+msgstr "å¯¹äºŽåœ¨æ•°æ®åº“é‡Œå­˜å‚¨å€¼çš„æ ‡è¯†ç¬¦ç”Ÿæˆå™¨ï¼Œç”Ÿæˆæ–°æ ‡è¯†ç¬¦æ—¶çš„æ¯æ¬¡è°ƒç”¨éƒ½è®¿é—®æ•°æ®åº“æ˜¯ä½Žæ•ˆçš„ã€‚å› æ­¤ï¼Œä½ å¯ä»¥æŠŠå®ƒä»¬åœ¨å†…å­˜é‡Œåˆ†ç»„å¹¶åªæœ‰åœ¨å¿«ç”¨å…‰å†…å­˜æ—¶æ‰è®¿é—®æ•°æ®åº“ã€‚è¿™æ˜¯å¯æ’æ‹” optimizer 的任务。目前只有两个增强型的生成器支持这个操作（<xref linkend=\"mapping-declaration-id-enhanced\"/>）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>none</literal> (generally this is the default if no optimizer was "
-"specified): this will not perform any optimizations and hit the database for "
-"each and every request."
-msgstr ""
-"<literal>none</literal>（如果没有指定 optimizer，通常这是缺省配置）：这不会执"
-"行任何优化，在每次请求时都访问数据库。"
+msgid "<literal>none</literal> (generally this is the default if no optimizer was specified): this will not perform any optimizations and hit the database for each and every request."
+msgstr "<literal>none</literal>（如果没有指定 optimizer，通常这是缺省配置）：这不会执行任何优化，在每次请求时都访问数据库。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>hilo</literal>: applies a hi/lo algorithm around the database "
-"retrieved values. The values from the database for this optimizer are "
-"expected to be sequential. The values retrieved from the database structure "
-"for this optimizer indicates the \"group number\". The "
-"<literal>increment_size</literal> is multiplied by that value in memory to "
-"define a group \"hi value\"."
-msgstr ""
-"<literal>hilo</literal>：对从数据库获取的值应用 hi/lo 算法。用于这个 "
-"optimizer 的从数据库获取的值应该是有序的。它们表明“组编号”。"
-"<literal>increment_size</literal> 将乘以内存里的值来定义组的“hi 值”。"
+msgid "<literal>hilo</literal>: applies a hi/lo algorithm around the database retrieved values. The values from the database for this optimizer are expected to be sequential. The values retrieved from the database structure for this optimizer indicates the \"group number\". The <literal>increment_size</literal> is multiplied by that value in memory to define a group \"hi value\"."
+msgstr "<literal>hilo</literal>：对从数据库获取的值应用 hi/lo 算法。用于这个 optimizer 的从数据库获取的值应该是有序的。它们表明“组编号”。<literal>increment_size</literal> 将乘以内存里的值来定义组的“hi 值”。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>pooled</literal>: as with the case of <literal>hilo</literal>, this "
-"optimizer attempts to minimize the number of hits to the database. Here, "
-"however, we simply store the starting value for the \"next group\" into the "
-"database structure rather than a sequential value in combination with an in-"
-"memory grouping algorithm. Here, <literal>increment_size</literal> refers to "
-"the values coming from the database."
-msgstr ""
-"<literal>pooled</literal>：和 <literal>hilo</literal> ä¸€æ ·ï¼Œè¿™ä¸ª optimizer 试"
-"图最小化对数据库的访问。然而，我们只是简单地把“下一组”的起始值而不是把序列值"
-"和分组算法的组合存入到数据库结构里。在这里，<literal>increment_size</"
-"literal> 表示数据库里的值。"
+msgid "<literal>pooled</literal>: as with the case of <literal>hilo</literal>, this optimizer attempts to minimize the number of hits to the database. Here, however, we simply store the starting value for the \"next group\" into the database structure rather than a sequential value in combination with an in-memory grouping algorithm. Here, <literal>increment_size</literal> refers to the values coming from the database."
+msgstr "<literal>pooled</literal>：和 <literal>hilo</literal> ä¸€æ ·ï¼Œè¿™ä¸ª optimizer 试图最小化对数据库的访问。然而，我们只是简单地把“下一组”的起始值而不是把序列值和分组算法的组合存入到数据库结构里。在这里，<literal>increment_size</literal> 表示数据库里的值。"
 
 #. Tag: title
 #, no-c-format
@@ -1398,147 +707,68 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A table with a composite key can be mapped with multiple properties of the "
-"class as identifier properties. The <literal>&lt;composite-id&gt;</literal> "
-"element accepts <literal>&lt;key-property&gt;</literal> property mappings "
-"and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements."
-msgstr ""
-"å¦‚æžœè¡¨ä½¿ç”¨è”åˆä¸»é”®ï¼Œä½ å¯ä»¥æ˜ å°„ç±»çš„å¤šä¸ªå±žæ€§ä¸ºæ ‡è¯†ç¬¦å±žæ€§ã€‚<literal>&lt;"
-"composite-id&gt;</literal> å…ƒç´ æŽ¥å— <literal>&lt;key-property&gt;</literal> "
-"å±žæ€§æ˜ å°„å’Œ <literal>&lt;key-many-to-one&gt;</literal> å±žæ€§æ˜ å°„ä½œä¸ºå­å…ƒç´ ã€‚ "
+msgid "A table with a composite key can be mapped with multiple properties of the class as identifier properties. The <literal>&lt;composite-id&gt;</literal> element accepts <literal>&lt;key-property&gt;</literal> property mappings and <literal>&lt;key-many-to-one&gt;</literal> mappings as child elements."
+msgstr "å¦‚æžœè¡¨ä½¿ç”¨è”åˆä¸»é”®ï¼Œä½ å¯ä»¥æ˜ å°„ç±»çš„å¤šä¸ªå±žæ€§ä¸ºæ ‡è¯†ç¬¦å±žæ€§ã€‚<literal>&lt;composite-id&gt;</literal> å…ƒç´ æŽ¥å— <literal>&lt;key-property&gt;</literal> å±žæ€§æ˜ å°„å’Œ <literal>&lt;key-many-to-one&gt;</literal> å±žæ€§æ˜ å°„ä½œä¸ºå­å…ƒç´ ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The persistent class <emphasis>must</emphasis> override <literal>equals()</"
-"literal> and <literal>hashCode()</literal> to implement composite identifier "
-"equality. It must also implement <literal>Serializable</literal>."
-msgstr ""
-"ä½ çš„æŒä¹…åŒ–ç±»<emphasis>å¿…é¡»</emphasis>覆盖 <literal>equals()</literal> å’Œ "
-"<literal>hashCode()</literal> æ–¹æ³•ï¼Œæ¥å®žçŽ°ç»„åˆçš„æ ‡è¯†ç¬¦çš„ç›¸ç­‰åˆ¤æ–­ã€‚å®žçŽ° "
-"<literal>Serializable</literal> 接口也是必须的。"
+msgid "The persistent class <emphasis>must</emphasis> override <literal>equals()</literal> and <literal>hashCode()</literal> to implement composite identifier equality. It must also implement <literal>Serializable</literal>."
+msgstr "ä½ çš„æŒä¹…åŒ–ç±»<emphasis>å¿…é¡»</emphasis>覆盖 <literal>equals()</literal> å’Œ <literal>hashCode()</literal> æ–¹æ³•ï¼Œæ¥å®žçŽ°ç»„åˆçš„æ ‡è¯†ç¬¦çš„ç›¸ç­‰åˆ¤æ–­ã€‚å®žçŽ° <literal>Serializable</literal> 接口也是必须的。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Unfortunately, this approach means that a persistent object is its own "
-"identifier. There is no convenient \"handle\" other than the object itself. "
-"You must instantiate an instance of the persistent class itself and populate "
-"its identifier properties before you can <literal>load()</literal> the "
-"persistent state associated with a composite key. We call this approach an "
-"<emphasis>embedded</emphasis> composite identifier, and discourage it for "
-"serious applications."
-msgstr ""
-"ä¸å¹¸çš„æ˜¯ï¼Œè¿™ç§ç»„åˆå…³é”®å­—çš„æ–¹æ³•æ„å‘³ç€ä¸€ä¸ªæŒä¹…åŒ–ç±»æ˜¯å®ƒè‡ªå·±çš„æ ‡è¯†ã€‚é™¤äº†å¯¹è±¡è‡ªå·±"
-"ä¹‹å¤–ï¼Œæ²¡æœ‰ä»€ä¹ˆæ–¹ä¾¿çš„â€œæŠŠæ‰‹â€å¯ç”¨ã€‚ä½ å¿…é¡»åˆå§‹åŒ–æŒä¹…åŒ–ç±»çš„å®žä¾‹ï¼Œå¡«å……å®ƒçš„æ ‡è¯†ç¬¦å±ž"
-"性，再 <literal>load()</literal> 组合关键字关联的持久状态。我们把这种方法称"
-"为 <emphasis>embedded（嵌入式）</emphasis>çš„ç»„åˆæ ‡è¯†ç¬¦ï¼Œåœ¨é‡è¦çš„åº”ç”¨ä¸­ä¸é¼“åŠ±"
-"使用这种用法。 "
+msgid "Unfortunately, this approach means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
+msgstr "ä¸å¹¸çš„æ˜¯ï¼Œè¿™ç§ç»„åˆå…³é”®å­—çš„æ–¹æ³•æ„å‘³ç€ä¸€ä¸ªæŒä¹…åŒ–ç±»æ˜¯å®ƒè‡ªå·±çš„æ ‡è¯†ã€‚é™¤äº†å¯¹è±¡è‡ªå·±ä¹‹å¤–ï¼Œæ²¡æœ‰ä»€ä¹ˆæ–¹ä¾¿çš„â€œæŠŠæ‰‹â€å¯ç”¨ã€‚ä½ å¿…é¡»åˆå§‹åŒ–æŒä¹…åŒ–ç±»çš„å®žä¾‹ï¼Œå¡«å……å®ƒçš„æ ‡è¯†ç¬¦å±žæ€§ï¼Œå† <literal>load()</literal> 组合关键字关联的持久状态。我们把这种方法称为 <emphasis>embedded（嵌入式）</emphasis>çš„ç»„åˆæ ‡è¯†ç¬¦ï¼Œåœ¨é‡è¦çš„åº”ç”¨ä¸­ä¸é¼“åŠ±ä½¿ç”¨è¿™ç§ç”¨æ³•ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A second approach is what we call a <emphasis>mapped</emphasis> composite "
-"identifier, where the identifier properties named inside the <literal>&lt;"
-"composite-id&gt;</literal> element are duplicated on both the persistent "
-"class and a separate identifier class."
-msgstr ""
-"第二种方法我们称为 <emphasis>mappedï¼ˆæ˜ å°„å¼ï¼‰</emphasis>ç»„åˆæ ‡è¯†ç¬¦ï¼ˆmapped "
-"composite identifier），<literal>&lt;composite-id&gt;</literal> å…ƒç´ ä¸­åˆ—å‡ºçš„"
-"æ ‡è¯†å±žæ€§ä¸ä½†åœ¨æŒä¹…åŒ–ç±»å‡ºçŽ°ï¼Œè¿˜å½¢æˆä¸€ä¸ªç‹¬ç«‹çš„æ ‡è¯†ç¬¦ç±»ã€‚"
+msgid "A second approach is what we call a <emphasis>mapped</emphasis> composite identifier, where the identifier properties named inside the <literal>&lt;composite-id&gt;</literal> element are duplicated on both the persistent class and a separate identifier class."
+msgstr "第二种方法我们称为 <emphasis>mappedï¼ˆæ˜ å°„å¼ï¼‰</emphasis>ç»„åˆæ ‡è¯†ç¬¦ï¼ˆmapped composite identifier），<literal>&lt;composite-id&gt;</literal> å…ƒç´ ä¸­åˆ—å‡ºçš„æ ‡è¯†å±žæ€§ä¸ä½†åœ¨æŒä¹…åŒ–ç±»å‡ºçŽ°ï¼Œè¿˜å½¢æˆä¸€ä¸ªç‹¬ç«‹çš„æ ‡è¯†ç¬¦ç±»ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In this example, both the composite identifier class, <literal>MedicareId</"
-"literal>, and the entity class itself have properties named "
-"<literal>medicareNumber</literal> and <literal>dependent</literal>. The "
-"identifier class must override <literal>equals()</literal> and "
-"<literal>hashCode()</literal> and implement <literal>Serializable</literal>. "
-"The main disadvantage of this approach is code duplication."
-msgstr ""
-"åœ¨è¿™ä¸ªä¾‹å­ä¸­ï¼Œç»„åˆæ ‡è¯†ç¬¦ç±» <literal>MedicareId</literal> 和实体类都含有 "
-"<literal>medicareNumber</literal> å’Œ <literal>dependent</literal> å±žæ€§ã€‚æ ‡è¯†"
-"符类必须重载 <literal>equals()</literal> 和 <literal>hashCode()</literal> 并"
-"且实现 <literal>Serializable</literal> æŽ¥å£ã€‚è¿™ç§æ–¹æ³•çš„ç¼ºç‚¹æ˜¯å‡ºçŽ°äº†æ˜Žæ˜¾çš„ä»£ç "
-"重复。"
+msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement <literal>Serializable</literal>. The main disadvantage of this approach is code duplication."
+msgstr "åœ¨è¿™ä¸ªä¾‹å­ä¸­ï¼Œç»„åˆæ ‡è¯†ç¬¦ç±» <literal>MedicareId</literal> 和实体类都含有 <literal>medicareNumber</literal> å’Œ <literal>dependent</literal> å±žæ€§ã€‚æ ‡è¯†ç¬¦ç±»å¿…é¡»é‡è½½ <literal>equals()</literal> å’Œ <literal>hashCode()</literal> 并且实现 <literal>Serializable</literal> æŽ¥å£ã€‚è¿™ç§æ–¹æ³•çš„ç¼ºç‚¹æ˜¯å‡ºçŽ°äº†æ˜Žæ˜¾çš„ä»£ç é‡å¤ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The following attributes are used to specify a mapped composite identifier:"
+msgid "The following attributes are used to specify a mapped composite identifier:"
 msgstr "ä¸‹é¢åˆ—å‡ºçš„å±žæ€§æ˜¯ç”¨æ¥æŒ‡å®šä¸€ä¸ªæ˜ å°„å¼ç»„åˆæ ‡è¯†ç¬¦çš„ï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>mapped</literal> (optional - defaults to <literal>false</literal>): "
-"indicates that a mapped composite identifier is used, and that the contained "
-"property mappings refer to both the entity class and the composite "
-"identifier class."
-msgstr ""
-"<literal>mapped</literal>（可选，默认为 <literal>false</literal>）：指明使用"
-"ä¸€ä¸ªæ˜ å°„å¼ç»„åˆæ ‡è¯†ç¬¦ï¼Œå…¶åŒ…å«çš„å±žæ€§æ˜ å°„åŒæ—¶åœ¨å®žä½“ç±»å’Œç»„åˆæ ‡è¯†ç¬¦ç±»ä¸­å‡ºçŽ°ã€‚ "
+msgid "<literal>mapped</literal> (optional - defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
+msgstr "<literal>mapped</literal>（可选，默认为 <literal>false</literal>ï¼‰ï¼šæŒ‡æ˜Žä½¿ç”¨ä¸€ä¸ªæ˜ å°„å¼ç»„åˆæ ‡è¯†ç¬¦ï¼Œå…¶åŒ…å«çš„å±žæ€§æ˜ å°„åŒæ—¶åœ¨å®žä½“ç±»å’Œç»„åˆæ ‡è¯†ç¬¦ç±»ä¸­å‡ºçŽ°ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>class</literal> (optional - but required for a mapped composite "
-"identifier): the class used as a composite identifier."
-msgstr ""
-"<literal>class</literal>（可选,ä½†å¯¹æ˜ å°„å¼ç»„åˆæ ‡è¯†ç¬¦å¿…é¡»æŒ‡å®šï¼‰ï¼šä½œä¸ºç»„åˆæ ‡è¯†ç¬¦"
-"类使用的类名。"
+msgid "<literal>class</literal> (optional - but required for a mapped composite identifier): the class used as a composite identifier."
+msgstr "<literal>class</literal>（可选,ä½†å¯¹æ˜ å°„å¼ç»„åˆæ ‡è¯†ç¬¦å¿…é¡»æŒ‡å®šï¼‰ï¼šä½œä¸ºç»„åˆæ ‡è¯†ç¬¦ç±»ä½¿ç”¨çš„ç±»åã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"We will describe a third, even more convenient approach, where the composite "
-"identifier is implemented as a component class in <xref linkend=\"components-"
-"compositeid\" />. The attributes described below apply only to this "
-"alternative approach:"
-msgstr ""
-"在 <xref linkend=\"components-compositeid\"/> 一节中,我们会描述第三种方式,那"
-"å°±æ˜¯æŠŠç»„åˆæ ‡è¯†ç¬¦å®žçŽ°ä¸ºä¸€ä¸ªç»„ä»¶ï¼ˆcomponent）类,这是更方便的方法。下面的属性仅"
-"对第三种方法有效："
+#, no-c-format
+msgid "We will describe a third, even more convenient approach, where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\" />. The attributes described below apply only to this alternative approach:"
+msgstr "在 <xref linkend=\"components-compositeid\"/> 一节中,我们会描述第三种方式,é‚£å°±æ˜¯æŠŠç»„åˆæ ‡è¯†ç¬¦å®žçŽ°ä¸ºä¸€ä¸ªç»„ä»¶ï¼ˆcomponent）类,这是更方便的方法。下面的属性仅对第三种方法有效： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>name</literal> (optional - required for this approach): a property "
-"of component type that holds the composite identifier. Please see chapter 9 "
-"for more information."
-msgstr ""
-"<literal>name</literal>（可选,ä½†å¯¹è¿™ç§æ–¹æ³•è€Œè¨€å¿…é¡»ï¼‰ï¼šåŒ…å«æ­¤ç»„ä»¶æ ‡è¯†ç¬¦çš„ç»„ä»¶"
-"类型的名字（参阅第 9 ç« ï¼‰ã€‚"
+msgid "<literal>name</literal> (optional - required for this approach): a property of component type that holds the composite identifier. Please see chapter 9 for more information."
+msgstr "<literal>name</literal>（可选,ä½†å¯¹è¿™ç§æ–¹æ³•è€Œè¨€å¿…é¡»ï¼‰ï¼šåŒ…å«æ­¤ç»„ä»¶æ ‡è¯†ç¬¦çš„ç»„ä»¶ç±»åž‹çš„åå­—ï¼ˆå‚é˜…ç¬¬ 9 ç« ï¼‰ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate uses for accessing the property value."
-msgstr ""
-"<literal>access</literal>（可选 — 默认为 <literal>property</literal>）："
-"Hibernate 用来访问属性值的策略。 "
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate uses for accessing the property value."
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>class</literal> (optional - defaults to the property type "
-"determined by reflection): the component class used as a composite "
-"identifier. Please see the next section for more information."
-msgstr ""
-"<literal>class</literal>（可选 — 默认会用反射来自动判定属性类型 ）：用来作为"
-"ç»„åˆæ ‡è¯†ç¬¦çš„ç»„ä»¶ç±»çš„ç±»åï¼ˆå‚é˜…ä¸‹ä¸€èŠ‚ï¼‰ã€‚ "
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the component class used as a composite identifier. Please see the next section for more information."
+msgstr "<literal>class</literal>（可选 — 默认会用反射来自动判定属性类型 ï¼‰ï¼šç”¨æ¥ä½œä¸ºç»„åˆæ ‡è¯†ç¬¦çš„ç»„ä»¶ç±»çš„ç±»åï¼ˆå‚é˜…ä¸‹ä¸€èŠ‚ï¼‰ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The third approach, an <emphasis>identifier component</emphasis>, is "
-"recommended for almost all applications."
-msgstr ""
-"第三种方式，被称为 <emphasis>identifier componentï¼ˆæ ‡è¯†ç¬¦ç»„ä»¶ï¼‰</emphasis>是"
-"æˆ‘ä»¬å¯¹å‡ ä¹Žæ‰€æœ‰åº”ç”¨éƒ½æŽ¨èä½¿ç”¨çš„æ–¹å¼ã€‚ "
+msgid "The third approach, an <emphasis>identifier component</emphasis>, is recommended for almost all applications."
+msgstr "第三种方式，被称为 <emphasis>identifier componentï¼ˆæ ‡è¯†ç¬¦ç»„ä»¶ï¼‰</emphasis>æ˜¯æˆ‘ä»¬å¯¹å‡ ä¹Žæ‰€æœ‰åº”ç”¨éƒ½æŽ¨èä½¿ç”¨çš„æ–¹å¼ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -1547,105 +777,48 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>&lt;discriminator&gt;</literal> element is required for "
-"polymorphic persistence using the table-per-class-hierarchy mapping "
-"strategy. It declares a discriminator column of the table. The discriminator "
-"column contains marker values that tell the persistence layer what subclass "
-"to instantiate for a particular row. A restricted set of types can be used: "
-"<literal>string</literal>, <literal>character</literal>, <literal>integer</"
-"literal>, <literal>byte</literal>, <literal>short</literal>, "
-"<literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</"
-"literal>."
-msgstr ""
-"在\"ä¸€æ£µå¯¹è±¡ç»§æ‰¿æ ‘å¯¹åº”ä¸€ä¸ªè¡¨\"的策略中，<literal>&lt;discriminator&gt;</"
-"literal> å…ƒç´ æ˜¯å¿…éœ€çš„ï¼Œå®ƒå®šä¹‰äº†è¡¨çš„é‰´åˆ«å™¨å­—æ®µã€‚é‰´åˆ«å™¨å­—æ®µåŒ…å«æ ‡å¿—å€¼ï¼Œç”¨äºŽå‘ŠçŸ¥"
-"持久化层应该为某个特定的行创建哪一个子类的实例。如下这些受到限制的类型可以使"
-"用：<literal>string</literal>、<literal>character</literal>、"
-"<literal>integer</literal>、<literal>byte</literal>、<literal>short</"
-"literal>、<literal>boolean</literal>、<literal>yes_no</literal>、"
-"<literal>true_false</literal>。"
+msgid "The <literal>&lt;discriminator&gt;</literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy. It declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types can be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
+msgstr "在\"ä¸€æ£µå¯¹è±¡ç»§æ‰¿æ ‘å¯¹åº”ä¸€ä¸ªè¡¨\"的策略中，<literal>&lt;discriminator&gt;</literal> å…ƒç´ æ˜¯å¿…éœ€çš„ï¼Œå®ƒå®šä¹‰äº†è¡¨çš„é‰´åˆ«å™¨å­—æ®µã€‚é‰´åˆ«å™¨å­—æ®µåŒ…å«æ ‡å¿—å€¼ï¼Œç”¨äºŽå‘ŠçŸ¥æŒä¹…åŒ–å±‚åº”è¯¥ä¸ºæŸä¸ªç‰¹å®šçš„è¡Œåˆ›å»ºå“ªä¸€ä¸ªå­ç±»çš„å®žä¾‹ã€‚å¦‚ä¸‹è¿™äº›å—åˆ°é™åˆ¶çš„ç±»åž‹å¯ä»¥ä½¿ç”¨ï¼š<literal>string</literal>、<literal>character</literal>、<literal>integer</literal>、<literal>byte</literal>、<literal>short</literal>、<literal>boolean</literal>、<literal>yes_no</literal>、<literal>true_false</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to <literal>class</literal>): "
-"the name of the discriminator column."
-msgstr ""
-"<literal>column</literal>（可选 — 默认为 <literal>class</literal>）"
-"discriminator 器字段的名字。"
+msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>): the name of the discriminator column."
+msgstr "<literal>column</literal>（可选 — 默认为 <literal>class</literal>）discriminator 器字段的名字。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>type</literal> (optional - defaults to <literal>string</literal>): "
-"a name that indicates the Hibernate type"
-msgstr ""
-"<literal>type</literal>（可选 — 默认为 <literal>string</literal>）一个 "
-"Hibernate 字段类型的名字 "
+msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>): a name that indicates the Hibernate type"
+msgstr "<literal>type</literal>（可选 — 默认为 <literal>string</literal>）一个 Hibernate 字段类型的名字 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>force</literal> (optional - defaults to <literal>false</literal>): "
-"\"forces\" Hibernate to specify the allowed discriminator values, even when "
-"retrieving all instances of the root class."
-msgstr ""
-"<literal>force(强制)</literal>（可选 — 默认为 <literal>false</literal>）\"强"
-"制\" Hibernate 指定允许的鉴别器值,å³ä½¿å½“å–å¾—çš„æ‰€æœ‰å®žä¾‹éƒ½æ˜¯æ ¹ç±»çš„ã€‚ "
+msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>): \"forces\" Hibernate to specify the allowed discriminator values, even when retrieving all instances of the root class."
+msgstr "<literal>force(强制)</literal>（可选 — 默认为 <literal>false</literal>）\"强制\" Hibernate 指定允许的鉴别器值,å³ä½¿å½“å–å¾—çš„æ‰€æœ‰å®žä¾‹éƒ½æ˜¯æ ¹ç±»çš„ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>insert</literal> (optional - defaults to <literal>true</literal>): "
-"set this to <literal>false</literal> if your discriminator column is also "
-"part of a mapped composite identifier. It tells Hibernate not to include the "
-"column in SQL <literal>INSERTs</literal>."
-msgstr ""
-"<literal>insert</literal>（可选 - 默认为<literal>true</literal>ï¼‰å¦‚æžœä½ çš„é‰´åˆ«"
-"å™¨å­—æ®µä¹Ÿæ˜¯æ˜ å°„ä¸ºå¤åˆæ ‡è¯†ï¼ˆcomposite identifier）的一部分，则需将这个值设为 "
-"<literal>false</literal>。（告诉 Hibernate 在做 SQL <literal>INSERT</"
-"literal> 时不包含该列） "
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. It tells Hibernate not to include the column in SQL <literal>INSERTs</literal>."
+msgstr "<literal>insert</literal>（可选 - 默认为<literal>true</literal>ï¼‰å¦‚æžœä½ çš„é‰´åˆ«å™¨å­—æ®µä¹Ÿæ˜¯æ˜ å°„ä¸ºå¤åˆæ ‡è¯†ï¼ˆcomposite identifier）的一部分，则需将这个值设为 <literal>false</literal>。（告诉 Hibernate 在做 SQL <literal>INSERT</literal> 时不包含该列） "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): an arbitrary SQL expression that is "
-"executed when a type has to be evaluated. It allows content-based "
-"discrimination."
-msgstr ""
-"<literal>formula</literal>（可选）一个 SQL 表达式，在类型判断（判断是父类还是"
-"具体子类 — 译注）时执行。可用于基于内容的鉴别器。 "
+msgid "<literal>formula</literal> (optional): an arbitrary SQL expression that is executed when a type has to be evaluated. It allows content-based discrimination."
+msgstr "<literal>formula</literal>（可选）一个 SQL 表达式，在类型判断（判断是父类还是具体子类 — 译注）时执行。可用于基于内容的鉴别器。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Actual values of the discriminator column are specified by the "
-"<literal>discriminator-value</literal> attribute of the <literal>&lt;"
-"class&gt;</literal> and <literal>&lt;subclass&gt;</literal> elements."
-msgstr ""
-"é‰´åˆ«å™¨å­—æ®µçš„å®žé™…å€¼æ˜¯æ ¹æ® <literal>&lt;class&gt;</literal> å’Œ <literal>&lt;"
-"subclass&gt;</literal> å…ƒç´ ä¸­çš„ <literal>discriminator-value</literal> 属性得"
-"来的。"
+msgid "Actual values of the discriminator column are specified by the <literal>discriminator-value</literal> attribute of the <literal>&lt;class&gt;</literal> and <literal>&lt;subclass&gt;</literal> elements."
+msgstr "é‰´åˆ«å™¨å­—æ®µçš„å®žé™…å€¼æ˜¯æ ¹æ® <literal>&lt;class&gt;</literal> å’Œ <literal>&lt;subclass&gt;</literal> å…ƒç´ ä¸­çš„ <literal>discriminator-value</literal> 属性得来的。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>force</literal> attribute is only useful if the table contains "
-"rows with \"extra\" discriminator values that are not mapped to a persistent "
-"class. This will not usually be the case."
-msgstr ""
-"<literal>force</literal> å±žæ€§ä»…ä»…åœ¨è¿™ç§æƒ…å†µä¸‹æœ‰ç”¨çš„ï¼šè¡¨ä¸­åŒ…å«æ²¡æœ‰è¢«æ˜ å°„åˆ°æŒä¹…"
-"åŒ–ç±»çš„é™„åŠ è¾¨åˆ«å™¨å€¼ã€‚è¿™ç§æƒ…å†µä¸ä¼šç»å¸¸é‡åˆ°ã€‚ "
+msgid "The <literal>force</literal> attribute is only useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
+msgstr "<literal>force</literal> å±žæ€§ä»…ä»…åœ¨è¿™ç§æƒ…å†µä¸‹æœ‰ç”¨çš„ï¼šè¡¨ä¸­åŒ…å«æ²¡æœ‰è¢«æ˜ å°„åˆ°æŒä¹…åŒ–ç±»çš„é™„åŠ è¾¨åˆ«å™¨å€¼ã€‚è¿™ç§æƒ…å†µä¸ä¼šç»å¸¸é‡åˆ°ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>formula</literal> attribute allows you to declare an arbitrary "
-"SQL expression that will be used to evaluate the type of a row. For example:"
-msgstr ""
-"使用 <literal>formula</literal> å±žæ€§ä½ å¯ä»¥å®šä¹‰ä¸€ä¸ª SQL 表达式，用来判断一行数"
-"据的类型。"
+msgid "The <literal>formula</literal> attribute allows you to declare an arbitrary SQL expression that will be used to evaluate the type of a row. For example:"
+msgstr "使用 <literal>formula</literal> å±žæ€§ä½ å¯ä»¥å®šä¹‰ä¸€ä¸ª SQL 表达式，用来判断一行数据的类型。"
 
 #. Tag: title
 #, no-c-format
@@ -1654,114 +827,53 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>&lt;version&gt;</literal> element is optional and indicates "
-"that the table contains versioned data. This is particularly useful if you "
-"plan to use <emphasis>long transactions</emphasis>. See below for more "
-"information:"
-msgstr ""
-"<literal>&lt;version&gt;</literal> å…ƒç´ æ˜¯å¯é€‰çš„ï¼Œè¡¨æ˜Žè¡¨ä¸­åŒ…å«é™„å¸¦ç‰ˆæœ¬ä¿¡æ¯çš„æ•°"
-"æ®ã€‚è¿™åœ¨ä½ å‡†å¤‡ä½¿ç”¨<emphasis> 长事务（long transactions）</emphasis>的时候特别"
-"有用。下面是更多信息："
+msgid "The <literal>&lt;version&gt;</literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis>. See below for more information:"
+msgstr "<literal>&lt;version&gt;</literal> å…ƒç´ æ˜¯å¯é€‰çš„ï¼Œè¡¨æ˜Žè¡¨ä¸­åŒ…å«é™„å¸¦ç‰ˆæœ¬ä¿¡æ¯çš„æ•°æ®ã€‚è¿™åœ¨ä½ å‡†å¤‡ä½¿ç”¨<emphasis> 长事务（long transactions）</emphasis>的时候特别有用。下面是更多信息："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of the column holding the version number."
-msgstr ""
-"<literal>column</literal>（可选 — 默认为属性名）：指定持有版本号的字段名。 "
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the column holding the version number."
+msgstr "<literal>column</literal>（可选 — 默认为属性名）：指定持有版本号的字段名。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>name</literal>: the name of a property of the persistent class."
+msgid "<literal>name</literal>: the name of a property of the persistent class."
 msgstr "<literal>name</literal>：持久化类的属性名。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>type</literal> (optional - defaults to <literal>integer</literal>): "
-"the type of the version number."
-msgstr ""
-"<literal>type</literal>（可选 — 默认是 <literal>integer</literal>）：版本号的"
-"类型。 "
+msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): the type of the version number."
+msgstr "<literal>type</literal>（可选 — 默认是 <literal>integer</literal>）：版本号的类型。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>access</literal> (optional - defaults to <literal>property</"
-"literal>): the strategy Hibernate uses to access the property value."
-msgstr ""
-"<literal>access</literal>（可选 — 默认为 <literal>property</literal>）："
-"Hibernate 用来访问属性值的策略。 "
+msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate uses to access the property value."
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</"
-"literal>): a version property value that indicates that an instance is newly "
-"instantiated (unsaved), distinguishing it from detached instances that were "
-"saved or loaded in a previous session. <literal>Undefined</literal> "
-"specifies that the identifier property value should be used."
-msgstr ""
-"<literal>unsaved-value</literal>（可选 — 默认是 <literal>undefined</"
-"literal>ï¼‰ï¼šç”¨äºŽæ ‡æ˜ŽæŸä¸ªå®žä¾‹æ—¶åˆšåˆšè¢«å®žä¾‹åŒ–çš„ï¼ˆå°šæœªä¿å­˜ï¼‰ç‰ˆæœ¬å±žæ€§å€¼ï¼Œä¾é è¿™ä¸ª"
-"值就可以把这种情况 和已经在先前的 session 中保存或装载的脱管（detached）实例"
-"区分开来。（<literal>undefined</literal> æŒ‡æ˜Žåº”è¢«ä½¿ç”¨çš„æ ‡è¯†å±žæ€§å€¼ã€‚ï¼‰ "
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): a version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. <literal>Undefined</literal> specifies that the identifier property value should be used."
+msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>undefined</literal>ï¼‰ï¼šç”¨äºŽæ ‡æ˜ŽæŸä¸ªå®žä¾‹æ—¶åˆšåˆšè¢«å®žä¾‹åŒ–çš„ï¼ˆå°šæœªä¿å­˜ï¼‰ç‰ˆæœ¬å±žæ€§å€¼ï¼Œä¾é è¿™ä¸ªå€¼å°±å¯ä»¥æŠŠè¿™ç§æƒ…å†µ 和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> æŒ‡æ˜Žåº”è¢«ä½¿ç”¨çš„æ ‡è¯†å±žæ€§å€¼ã€‚ï¼‰ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>generated</literal> (optional - defaults to <literal>never</"
-"literal>): specifies that this version property value is generated by the "
-"database. See the discussion of <xref linkend=\"mapping-generated\" /> for "
-"more information."
-msgstr ""
-"<literal>generated</literal>（可选 — 默认是 <literal>never</literal>）：表明"
-"此版本属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-"
-"generated\"/> 部分的讨论。"
+#, no-c-format
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this version property value is generated by the database. See the discussion of <xref linkend=\"mapping-generated\" /> for more information."
+msgstr "<literal>generated</literal>（可选 — 默认是 <literal>never</literal>）：表明此版本属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-generated\"/> 部分的讨论。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>insert</literal> (optional - defaults to <literal>true</literal>): "
-"specifies whether the version column should be included in SQL insert "
-"statements. It can be set to <literal>false</literal> if the database column "
-"is defined with a default value of <literal>0</literal>."
-msgstr ""
-"<literal>insert</literal>（可选 — 默认是 <literal>true</literal>）：表明此版"
-"本列应该包含在 SQL 插入语句中。只有当数据库字段有默认值 <literal>0</literal> "
-"的时候，才可以设置为 <literal>false</literal>。 "
+msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): specifies whether the version column should be included in SQL insert statements. It can be set to <literal>false</literal> if the database column is defined with a default value of <literal>0</literal>."
+msgstr "<literal>insert</literal>（可选 — 默认是 <literal>true</literal>）：表明此版本列应该包含在 SQL 插入语句中。只有当数据库字段有默认值 <literal>0</literal> 的时候，才可以设置为 <literal>false</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Version numbers can be of Hibernate type <literal>long</literal>, "
-"<literal>integer</literal>, <literal>short</literal>, <literal>timestamp</"
-"literal> or <literal>calendar</literal>."
-msgstr ""
-"版本号必须是以下类型：<literal>long</literal>、<literal>integer</literal>、"
-"<literal>short</literal>、<literal>timestamp</literal> 或者 "
-"<literal>calendar</literal>。"
+msgid "Version numbers can be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
+msgstr "版本号必须是以下类型：<literal>long</literal>、<literal>integer</literal>、<literal>short</literal>、<literal>timestamp</literal> 或者 <literal>calendar</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A version or timestamp property should never be null for a detached "
-"instance. Hibernate will detect any instance with a null version or "
-"timestamp as transient, irrespective of what other <literal>unsaved-value</"
-"literal> strategies are specified. <emphasis>Declaring a nullable version or "
-"timestamp property is an easy way to avoid problems with transitive "
-"reattachment in Hibernate. It is especially useful for people using assigned "
-"identifiers or composite keys</emphasis>."
-msgstr ""
-"一个脱管（detached）实例的 version 或 timestamp 属性不能为空（nullï¼‰ï¼Œå› ä¸º "
-"Hibernate 不管  <literal>unsaved-value</literal> 被指定为何种策略，它将任何属"
-"性为空的 version 或 timestamp 实例看作为瞬时（transient）实例。 <emphasis>避"
-"免 Hibernate ä¸­çš„ä¼ é€’é‡é™„ï¼ˆtransitive reattachment）问题的一个简单方法是 定义"
-"一个不能为空的 version 或 timestamp å±žæ€§ï¼Œç‰¹åˆ«æ˜¯åœ¨äººä»¬ä½¿ç”¨ç¨‹åºåˆ†é…çš„æ ‡è¯†ç¬¦"
-"（assigned identifiers） 或复合主键时非常有用</emphasis>。"
+msgid "A version or timestamp property should never be null for a detached instance. Hibernate will detect any instance with a null version or timestamp as transient, irrespective of what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid problems with transitive reattachment in Hibernate. It is especially useful for people using assigned identifiers or composite keys</emphasis>."
+msgstr "一个脱管（detached）实例的 version 或 timestamp 属性不能为空（nullï¼‰ï¼Œå› ä¸º Hibernate 不管  <literal>unsaved-value</literal> 被指定为何种策略，它将任何属性为空的 version 或 timestamp 实例看作为瞬时（transient）实例。 <emphasis>避免 Hibernate ä¸­çš„ä¼ é€’é‡é™„ï¼ˆtransitive reattachment）问题的一个简单方法是 定义一个不能为空的 version 或 timestamp å±žæ€§ï¼Œç‰¹åˆ«æ˜¯åœ¨äººä»¬ä½¿ç”¨ç¨‹åºåˆ†é…çš„æ ‡è¯†ç¬¦ï¼ˆassigned identifiers） 或复合主键时非常有用</emphasis>。"
 
 #. Tag: title
 #, no-c-format
@@ -1770,78 +882,33 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The optional <literal>&lt;timestamp&gt;</literal> element indicates that the "
-"table contains timestamped data. This provides an alternative to versioning. "
-"Timestamps are a less safe implementation of optimistic locking. However, "
-"sometimes the application might use the timestamps in other ways."
-msgstr ""
-"可选的 <literal>&lt;timestamp&gt;</literal> å…ƒç´ æŒ‡æ˜Žäº†è¡¨ä¸­åŒ…å«æ—¶é—´æˆ³æ•°æ®ã€‚è¿™"
-"用来作为版本的替代。时间戳本质上是一种对乐观锁定的一种不是特别安全的实现。当"
-"然，有时候应用程序可能在其他方面使用时间戳。 "
+msgid "The optional <literal>&lt;timestamp&gt;</literal> element indicates that the table contains timestamped data. This provides an alternative to versioning. Timestamps are a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
+msgstr "可选的 <literal>&lt;timestamp&gt;</literal> å…ƒç´ æŒ‡æ˜Žäº†è¡¨ä¸­åŒ…å«æ—¶é—´æˆ³æ•°æ®ã€‚è¿™ç”¨æ¥ä½œä¸ºç‰ˆæœ¬çš„æ›¿ä»£ã€‚æ—¶é—´æˆ³æœ¬è´¨ä¸Šæ˜¯ä¸€ç§å¯¹ä¹è§‚é”å®šçš„ä¸€ç§ä¸æ˜¯ç‰¹åˆ«å®‰å…¨çš„å®žçŽ°ã€‚å½“ç„¶ï¼Œæœ‰æ—¶å€™åº”ç”¨ç¨‹åºå¯èƒ½åœ¨å…¶ä»–æ–¹é¢ä½¿ç”¨æ—¶é—´æˆ³ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of a column holding the timestamp."
-msgstr ""
-"<literal>column</literal>（可选 — 默认为属性名）：存有时间戳的字段名。 "
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of a column holding the timestamp."
+msgstr "<literal>column</literal>（可选 — 默认为属性名）：存有时间戳的字段名。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>name</literal>: the name of a JavaBeans style property of Java type "
-"<literal>Date</literal> or <literal>Timestamp</literal> of the persistent "
-"class."
-msgstr ""
-"<literal>name</literal>：在持久化类中的 JavaBeans é£Žæ ¼çš„å±žæ€§åï¼Œå…¶ Java 类型"
-"是 <literal>Date</literal> 或者 <literal>Timestamp</literal> 的。 "
+msgid "<literal>name</literal>: the name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
+msgstr "<literal>name</literal>：在持久化类中的 JavaBeans é£Žæ ¼çš„å±žæ€§åï¼Œå…¶ Java 类型是 <literal>Date</literal> 或者 <literal>Timestamp</literal> 的。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>unsaved-value</literal> (optional - defaults to <literal>null</"
-"literal>): a version property value that indicates that an instance is newly "
-"instantiated (unsaved), distinguishing it from detached instances that were "
-"saved or loaded in a previous session. <literal>Undefined</literal> "
-"specifies that the identifier property value should be used."
-msgstr ""
-"<literal>unsaved-value</literal>（可选 — 默认是 <literal>null</literal>）：用"
-"äºŽæ ‡æ˜ŽæŸä¸ªå®žä¾‹æ—¶åˆšåˆšè¢«å®žä¾‹åŒ–çš„ï¼ˆå°šæœªä¿å­˜ï¼‰ç‰ˆæœ¬å±žæ€§å€¼ï¼Œä¾é è¿™ä¸ªå€¼å°±å¯ä»¥æŠŠè¿™ç§"
-"情况和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。"
-"（<literal>undefined</literal> æŒ‡æ˜Žä½¿ç”¨æ ‡è¯†å±žæ€§å€¼è¿›è¡Œè¿™ç§åˆ¤æ–­ã€‚ï¼‰ "
+msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): a version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. <literal>Undefined</literal> specifies that the identifier property value should be used."
+msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>null</literal>ï¼‰ï¼šç”¨äºŽæ ‡æ˜ŽæŸä¸ªå®žä¾‹æ—¶åˆšåˆšè¢«å®žä¾‹åŒ–çš„ï¼ˆå°šæœªä¿å­˜ï¼‰ç‰ˆæœ¬å±žæ€§å€¼ï¼Œä¾é è¿™ä¸ªå€¼å°±å¯ä»¥æŠŠè¿™ç§æƒ…å†µå’Œå·²ç»åœ¨å…ˆå‰çš„ session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> æŒ‡æ˜Žä½¿ç”¨æ ‡è¯†å±žæ€§å€¼è¿›è¡Œè¿™ç§åˆ¤æ–­ã€‚ï¼‰ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>source</literal> (optional - defaults to <literal>vm</literal>): "
-"Where should Hibernate retrieve the timestamp value from? From the database, "
-"or from the current JVM? Database-based timestamps incur an overhead because "
-"Hibernate must hit the database in order to determine the \"next value\". It "
-"is safer to use in clustered environments. Not all <literal>Dialects</"
-"literal> are known to support the retrieval of the database's current "
-"timestamp. Others may also be unsafe for usage in locking due to lack of "
-"precision (Oracle 8, for example)."
-msgstr ""
-"<literal>source</literal>（可选 — 默认是 <literal>vm</literal>）：Hibernate "
-"如何才能获取到时间戳的值呢？从数据库，还是当前 JVM？从数据库获取会带来一些负"
-"æ‹…ï¼Œå› ä¸º Hibernate 必须访问数据库来获得“下一个值”，但是在集群环境中会更安全"
-"些。还要注意，并不是所有的 <literal>Dialect（方言）</literal>都支持获得数据库"
-"çš„å½“å‰æ—¶é—´æˆ³çš„ï¼Œè€Œæ”¯æŒçš„æ•°æ®åº“ä¸­åˆæœ‰ä¸€éƒ¨åˆ†å› ä¸ºç²¾åº¦ä¸è¶³ï¼Œç”¨äºŽé”å®šæ˜¯ä¸å®‰å…¨çš„"
-"（例如 Oracle 8）。 "
+msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): Where should Hibernate retrieve the timestamp value from? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\". It is safer to use in clustered environments. Not all <literal>Dialects</literal> are known to support the retrieval of the database's current timestamp. Others may also be unsafe for usage in locking due to lack of precision (Oracle 8, for example)."
+msgstr "<literal>source</literal>（可选 — 默认是 <literal>vm</literal>）：Hibernate 如何才能获取到时间戳的值呢？从数据库，还是当前 JVMï¼Ÿä»Žæ•°æ®åº“èŽ·å–ä¼šå¸¦æ¥ä¸€äº›è´Ÿæ‹…ï¼Œå› ä¸º Hibernate 必须访问数据库来获得“下一个值”，但是在集群环境中会更安全些。还要注意，并不是所有的 <literal>Dialect（方言）</literal>éƒ½æ”¯æŒèŽ·å¾—æ•°æ®åº“çš„å½“å‰æ—¶é—´æˆ³çš„ï¼Œè€Œæ”¯æŒçš„æ•°æ®åº“ä¸­åˆæœ‰ä¸€éƒ¨åˆ†å› ä¸ºç²¾åº¦ä¸è¶³ï¼Œç”¨äºŽé”å®šæ˜¯ä¸å®‰å…¨çš„ï¼ˆä¾‹å¦‚ Oracle 8）。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>generated</literal> (optional - defaults to <literal>never</"
-"literal>): specifies that this timestamp property value is actually "
-"generated by the database. See the discussion of <xref linkend=\"mapping-"
-"generated\" /> for more information."
-msgstr ""
-"<literal>generated</literal>（可选 - 默认是 <literal>never</literal>）：指出"
-"时间戳值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-generated"
-"\"/> 的讨论。"
+#, no-c-format
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\" /> for more information."
+msgstr "<literal>generated</literal>（可选 - 默认是 <literal>never</literal>）：指出时间戳值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-generated\"/> 的讨论。 "
 
 #. Tag: title
 #, no-c-format
@@ -1850,16 +917,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>&lt;Timestamp&gt;</literal> is equivalent to <literal>&lt;version "
-"type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db"
-"\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp"
-"\"&gt;</literal>"
-msgstr ""
-"注意，<literal>&lt;timestamp&gt;</literal> 和 <literal>&lt;version type="
-"\"timestamp\"&gt;</literal> 是等价的。并且 <literal>&lt;timestamp source=\"db"
-"\"&gt;</literal> 和 <literal>&lt;version type=\"dbtimestamp\"&gt;</literal> "
-"是等价的。 "
+msgid "<literal>&lt;Timestamp&gt;</literal> is equivalent to <literal>&lt;version type=\"timestamp\"&gt;</literal>. And <literal>&lt;timestamp source=\"db\"&gt;</literal> is equivalent to <literal>&lt;version type=\"dbtimestamp\"&gt;</literal>"
+msgstr "注意，<literal>&lt;timestamp&gt;</literal> 和 <literal>&lt;version type=\"timestamp\"&gt;</literal> 是等价的。并且 <literal>&lt;timestamp source=\"db\"&gt;</literal> 和 <literal>&lt;version type=\"dbtimestamp\"&gt;</literal> 是等价的。 "
 
 #. Tag: title
 #, no-c-format
@@ -1868,109 +927,53 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>&lt;property&gt;</literal> element declares a persistent "
-"JavaBean style property of the class."
-msgstr ""
-"<literal>&lt;property&gt;</literal> å…ƒç´ ä¸ºç±»å®šä¹‰äº†ä¸€ä¸ªæŒä¹…åŒ–çš„ã€JavaBean é£Žæ ¼"
-"的属性。 "
+msgid "The <literal>&lt;property&gt;</literal> element declares a persistent JavaBean style property of the class."
+msgstr "<literal>&lt;property&gt;</literal> å…ƒç´ ä¸ºç±»å®šä¹‰äº†ä¸€ä¸ªæŒä¹…åŒ–çš„ã€JavaBean é£Žæ ¼çš„å±žæ€§ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>name</literal>: the name of the property, with an initial lowercase "
-"letter."
+msgid "<literal>name</literal>: the name of the property, with an initial lowercase letter."
 msgstr "<literal>name</literal>：属性的名字，以小写字母开头。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional - defaults to the property name): the "
-"name of the mapped database table column. This can also be specified by "
-"nested <literal>&lt;column&gt;</literal> element(s)."
-msgstr ""
-"<literal>column</literal>（可选 — 默认为属性名字）：对应的数据库字段名。 也可"
-"以通过嵌套的 <literal>&lt;column&gt;</literal> å…ƒç´ æŒ‡å®šã€‚"
+#, no-c-format
+msgid "<literal>column</literal> (optional - defaults to the property name): the name of the mapped database table column. This can also be specified by nested <literal>&lt;column&gt;</literal> element(s)."
+msgstr "<literal>column</literal>（可选 — 默认为属性名字）：对应的数据库字段名。也可以通过嵌套的 <literal>&lt;column&gt;</literal> å…ƒç´ æŒ‡å®šã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>update, insert</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that the mapped columns should be included in SQL "
-"<literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. "
-"Setting both to <literal>false</literal> allows a pure \"derived\" property "
-"whose value is initialized from some other property that maps to the same "
-"column(s), or by a trigger or other application."
-msgstr ""
-"<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）： "
-"表明用于　<literal>UPDATE</literal> 和/或 <literal>INSERT</literal> 的 SQL 语"
-"å¥ä¸­æ˜¯å¦åŒ…å«è¿™ä¸ªè¢«æ˜ å°„äº†çš„å­—æ®µã€‚è¿™äºŒè€…å¦‚æžœéƒ½è®¾ç½®ä¸º <literal>false</literal> "
-"则表明这是一个“外源性（derivedï¼‰â€çš„å±žæ€§ï¼Œå®ƒçš„å€¼æ¥æºäºŽæ˜ å°„åˆ°åŒä¸€ä¸ªï¼ˆæˆ–å¤šä¸ªï¼‰ "
-"字段的某些其他属性，或者通过一个 trigger（触发器）或其他程序生成。"
+#, no-c-format
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>): specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" property whose value is initialized from some other property that maps to the same column(s), or by a trigger or other application."
+msgstr "<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）： 表明用于　<literal>UPDATE</literal> å’Œ/或 <literal>INSERT</literal> çš„ SQL è¯­å¥ä¸­æ˜¯å¦åŒ…å«è¿™ä¸ªè¢«æ˜ å°„äº†çš„å­—æ®µã€‚è¿™äºŒè€…å¦‚æžœéƒ½è®¾ç½®ä¸º <literal>false</literal> 则表明这是一个“外源性（derivedï¼‰â€çš„å±žæ€§ï¼Œå®ƒçš„å€¼æ¥æºäºŽæ˜ å°„åˆ°åŒä¸€ä¸ªï¼ˆæˆ–å¤šä¸ªï¼‰ 字段的某些其他属性，或者通过一个 trigger（触发器）或其他程序生成。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): an SQL expression that defines the "
-"value for a <emphasis>computed</emphasis> property. Computed properties do "
-"not have a column mapping of their own."
-msgstr ""
-"<literal>formula</literal>（可选）：一个 SQL 表达式，定义了这个<emphasis>计"
-"算 （computed）</emphasis> 属性的值。计算属性没有和它对应的数据库字段。"
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> property. Computed properties do not have a column mapping of their own."
+msgstr "<literal>formula</literal>（可选）：一个 SQL 表达式，定义了这个<emphasis>计算 （computed）</emphasis> 属性的值。计算属性没有和它对应的数据库字段。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>false</literal>): "
-"specifies that this property should be fetched lazily when the instance "
-"variable is first accessed. It requires build-time bytecode instrumentation."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认为 <literal>false</literal>）：指定 指定"
-"实例变量第一次被访问时，这个属性是否延迟抓取（fetched lazily）（ 需要运行时字"
-"èŠ‚ç å¢žå¼ºï¼‰ã€‚"
+#, no-c-format
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): specifies that this property should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation."
+msgstr "<literal>lazy</literal>（可选 — 默认为 <literal>false</literal>）：指定指定实例变量第一次被访问时，这个属性是否延迟抓取（fetched lazily）（ éœ€è¦è¿è¡Œæ—¶å­—èŠ‚ç å¢žå¼ºï¼‰ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional): enables the DDL generation of a unique "
-"constraint for the columns. Also, allow this to be the target of a "
-"<literal>property-ref</literal>."
-msgstr ""
-"<literal>unique</literal>（可选）：使用 DDL ä¸ºè¯¥å­—æ®µæ·»åŠ å”¯ä¸€çš„çº¦æŸã€‚åŒæ ·ï¼Œå…"
-"许它作为 <literal>property-ref</literal> å¼•ç”¨çš„ç›®æ ‡ã€‚"
+#, no-c-format
+msgid "<literal>unique</literal> (optional): enables the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a <literal>property-ref</literal>."
+msgstr "<literal>unique</literal>（可选）：使用 DDL ä¸ºè¯¥å­—æ®µæ·»åŠ å”¯ä¸€çš„çº¦æŸã€‚åŒæ ·ï¼Œå…è®¸å®ƒä½œä¸º <literal>property-ref</literal> å¼•ç”¨çš„ç›®æ ‡ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>not-null</literal> (optional): enables the DDL generation of a "
-"nullability constraint for the columns."
-msgstr ""
-"<literal>not-null</literal>（可选）：使用 DDL ä¸ºè¯¥å­—æ®µæ·»åŠ å¯å¦ä¸ºç©º"
-"（nullability）的约束。"
+#, no-c-format
+msgid "<literal>not-null</literal> (optional): enables the DDL generation of a nullability constraint for the columns."
+msgstr "<literal>not-null</literal>（可选）：使用 DDL ä¸ºè¯¥å­—æ®µæ·»åŠ å¯å¦ä¸ºç©ºï¼ˆnullability）的约束。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to this property do or do not require "
-"acquisition of the optimistic lock. In other words, it determines if a "
-"version increment should occur when this property is dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认为 <literal>true</literal>）："
-"指定这个属性在做更新时是否需要获得乐观锁定（optimistic lock）。换句话说，它决"
-"定这个属性发生脏数据时版本（version）的值是否增长。"
+#, no-c-format
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, it determines if a version increment should occur when this property is dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认为 <literal>true</literal>）：指定这个属性在做更新时是否需要获得乐观锁定（optimistic lock）。换句话说，它决定这个属性发生脏数据时版本（version）的值是否增长。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>generated</literal> (optional - defaults to <literal>never</"
-"literal>): specifies that this property value is actually generated by the "
-"database. See the discussion of <xref linkend=\"mapping-generated\" /> for "
-"more information."
-msgstr ""
-"<literal>generated</literal>（可选 — 默认为 <literal>never</literal>）：表明"
-"此属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-"
-"Generated_Properties\"/> 的讨论。"
+#, no-c-format
+msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\" /> for more information."
+msgstr "<literal>generated</literal>（可选 — 默认为 <literal>never</literal>）：表明此属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-generated\" /> 的讨论。"
 
 #. Tag: para
 #, no-c-format
@@ -1978,24 +981,14 @@
 msgstr "<emphasis>typename</emphasis> å¯ä»¥æ˜¯å¦‚ä¸‹å‡ ç§ï¼š"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The name of a Hibernate basic type: <literal>integer, string, character, "
-"date, timestamp, float, binary, serializable, object, blob</literal> etc."
-msgstr ""
-"Hibernate 基本类型名（比如：<literal>integer, string, character,date, "
-"timestamp, float, binary, serializable, object, blob</literal>）。"
+#, no-c-format
+msgid "The name of a Hibernate basic type: <literal>integer, string, character, date, timestamp, float, binary, serializable, object, blob</literal> etc."
+msgstr "Hibernate 基本类型名（比如：<literal>integer, string, character,date, timestamp, float, binary, serializable, object, blob</literal>）。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The name of a Java class with a default basic type: <literal>int, float, "
-"char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</"
-"literal> etc."
-msgstr ""
-"一个 Java 类的名字，这个类属于一种默认基础类型（比如：<literal>int, float,"
-"char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</"
-"literal>)。"
+#, no-c-format
+msgid "The name of a Java class with a default basic type: <literal>int, float, char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal> etc."
+msgstr "一个 Java 类的名字，这个类属于一种默认基础类型（比如：<literal>int, float,char, java.lang.String, java.util.Date, java.lang.Integer, java.sql.Clob</literal>)。 "
 
 #. Tag: para
 #, no-c-format
@@ -2003,269 +996,119 @@
 msgstr "一个可以序列化的 Java 类的名字。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The class name of a custom type: <literal>com.illflow.type.MyCustomType</"
-"literal> etc."
-msgstr ""
-"一个自定义类型的类的名字。（比如：<literal>com.illflow.type.MyCustomType</"
-"literal>)。"
+#, no-c-format
+msgid "The class name of a custom type: <literal>com.illflow.type.MyCustomType</literal> etc."
+msgstr "一个自定义类型的类的名字，如：<literal>com.illflow.type.MyCustomType</literal>。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If you do not specify a type, Hibernate will use reflection upon the named "
-"property and guess the correct Hibernate type. Hibernate will attempt to "
-"interpret the name of the return class of the property getter using, in "
-"order, rules 2, 3, and 4. In certain cases you will need the <literal>type</"
-"literal> attribute. For example, to distinguish between <literal>Hibernate."
-"DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a "
-"custom type."
-msgstr ""
-"å¦‚æžœä½ æ²¡æœ‰æŒ‡å®šç±»åž‹ï¼ŒHibernarte 会使用反射来得到这个名字的属性，以此来猜测正确"
-"的 Hibernate 类型。Hibernate 会按照规则 2，3，4 的顺序对属性读取器（getter方"
-"法）的返回类进行解释。然而，这还不够。 åœ¨æŸäº›æƒ…å†µä¸‹ä½ ä»ç„¶éœ€è¦ <literal>type</"
-"literal> 属性。（比如，为了区别<literal>Hibernate.DATE</literal> 和"
-"<literal>Hibernate.TIMESTAMP</literal>,或者为了指定一个自定义类型。）"
+#, no-c-format
+msgid "If you do not specify a type, Hibernate will use reflection upon the named property and guess the correct Hibernate type. Hibernate will attempt to interpret the name of the return class of the property getter using, in order, rules 2, 3, and 4. In certain cases you will need the <literal>type</literal> attribute. For example, to distinguish between <literal>Hibernate.DATE</literal> and <literal>Hibernate.TIMESTAMP</literal>, or to specify a custom type."
+msgstr "å¦‚æžœä½ æ²¡æœ‰æŒ‡å®šç±»åž‹ï¼ŒHibernarte 会使用反射来得到这个名字的属性，以此来猜测正确的 Hibernate 类型。Hibernate 会按照规则 2，3，4 的顺序对属性读取器（getter方法）的返回类进行解释。然而，这还不够。 åœ¨æŸäº›æƒ…å†µä¸‹ä½ ä»ç„¶éœ€è¦ <literal>type</literal> 属性。（比如，为了区别<literal>Hibernate.DATE</literal> å’Œ<literal>Hibernate.TIMESTAMP</literal>,或者为了指定一个自定义类型。） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>access</literal> attribute allows you to control how Hibernate "
-"accesses the property at runtime. By default, Hibernate will call the "
-"property get/set pair. If you specify <literal>access=\"field\"</literal>, "
-"Hibernate will bypass the get/set pair and access the field directly using "
-"reflection. You can specify your own strategy for property access by naming "
-"a class that implements the interface <literal>org.hibernate.property."
-"PropertyAccessor</literal>."
-msgstr ""
-"<literal>access</literal> å±žæ€§ç”¨æ¥è®©ä½ æŽ§åˆ¶ Hibernate 如何在运行时访问属性。在"
-"默认情况下，Hibernate 会使用属性的 get/set 方法对（pairï¼‰ã€‚å¦‚æžœä½ æŒ‡æ˜Ž "
-"<literal>access=\"field\"</literal>，Hibernate 会忽略 get/set 方法对，直接使"
-"ç”¨åå°„æ¥è®¿é—®æˆå‘˜å˜é‡ã€‚ä½ ä¹Ÿå¯ä»¥æŒ‡å®šä½ è‡ªå·±çš„ç­–ç•¥ï¼Œè¿™å°±éœ€è¦ä½ è‡ªå·±å®žçŽ° "
-"<literal>org.hibernate.property.PropertyAccessor</literal> 接口，再在 access "
-"ä¸­è®¾ç½®ä½ è‡ªå®šä¹‰ç­–ç•¥ç±»çš„åå­—ã€‚"
+#, no-c-format
+msgid "The <literal>access</literal> attribute allows you to control how Hibernate accesses the property at runtime. By default, Hibernate will call the property get/set pair. If you specify <literal>access=\"field\"</literal>, Hibernate will bypass the get/set pair and access the field directly using reflection. You can specify your own strategy for property access by naming a class that implements the interface <literal>org.hibernate.property.PropertyAccessor</literal>."
+msgstr "<literal>access</literal> å±žæ€§ç”¨æ¥è®©ä½ æŽ§åˆ¶ Hibernate 如何在运行时访问属性。在默认情况下，Hibernate 会使用属性的 get/set 方法对（pairï¼‰ã€‚å¦‚æžœä½ æŒ‡æ˜Ž <literal>access=\"field\"</literal>，Hibernate 会忽略 get/set æ–¹æ³•å¯¹ï¼Œç›´æŽ¥ä½¿ç”¨åå°„æ¥è®¿é—®æˆå‘˜å˜é‡ã€‚ä½ ä¹Ÿå¯ä»¥æŒ‡å®šä½ è‡ªå·±çš„ç­–ç•¥ï¼Œè¿™å°±éœ€è¦ä½ è‡ªå·±å®žçŽ° <literal>org.hibernate.property.PropertyAccessor</literal> 接口，再在 access ä¸­è®¾ç½®ä½ è‡ªå®šä¹‰ç­–ç•¥ç±»çš„åå­—ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A powerful feature is derived properties. These properties are by definition "
-"read-only. The property value is computed at load time. You declare the "
-"computation as an SQL expression. This then translates to a <literal>SELECT</"
-"literal> clause subquery in the SQL query that loads an instance:"
-msgstr ""
-"衍生属性（derive propertie）是一个特别强大的特征。这些属性应该定义为只读，属"
-"性值在装载时计算生成。 ä½ ç”¨ä¸€ä¸ª SQL 表达式生成计算的结果，它会在这个实例转载"
-"时翻译成一个 SQL 查询的 <literal>SELECT</literal> 子查询语句。"
+#, no-c-format
+msgid "A powerful feature is derived properties. These properties are by definition read-only. The property value is computed at load time. You declare the computation as an SQL expression. This then translates to a <literal>SELECT</literal> clause subquery in the SQL query that loads an instance:"
+msgstr "衍生属性（derive propertie）是一个特别强大的特征。这些属性应该定义为只读，属性值在装载时计算生成。 ä½ ç”¨ä¸€ä¸ª SQL 表达式生成计算的结果，它会在这个实例转载时翻译成一个 SQL 查询的 <literal>SELECT</literal> 子查询语句："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can reference the entity table by not declaring an alias on a particular "
-"column. This would be <literal>customerId</literal> in the given example. "
-"You can also use the nested <literal>&lt;formula&gt;</literal> mapping "
-"element if you do not want to use the attribute."
-msgstr ""
-"æ³¨æ„ï¼Œä½ å¯ä»¥ä½¿ç”¨å®žä½“è‡ªå·±çš„è¡¨ï¼Œè€Œä¸ç”¨ä¸ºè¿™ä¸ªç‰¹åˆ«çš„åˆ—å®šä¹‰åˆ«åï¼ˆä¸Šé¢ä¾‹å­ä¸­çš„"
-"<literal>customerId</literal>ï¼‰ã€‚åŒæ—¶æ³¨æ„ï¼Œå¦‚æžœä½ ä¸å–œæ¬¢ä½¿ç”¨å±žæ€§ï¼Œ ä½ å¯ä»¥ä½¿ç”¨"
-"嵌套的 <literal>&lt;formula&gt;</literal> æ˜ å°„å…ƒç´ ã€‚"
+#, no-c-format
+msgid "You can reference the entity table by not declaring an alias on a particular column. This would be <literal>customerId</literal> in the given example. You can also use the nested <literal>&lt;formula&gt;</literal> mapping element if you do not want to use the attribute."
+msgstr "æ³¨æ„ï¼Œä½ å¯ä»¥ä½¿ç”¨å®žä½“è‡ªå·±çš„è¡¨ï¼Œè€Œä¸ç”¨ä¸ºè¿™ä¸ªç‰¹åˆ«çš„åˆ—å®šä¹‰åˆ«åï¼ˆä¸Šé¢ä¾‹å­ä¸­çš„<literal>customerId</literal>ï¼‰ã€‚åŒæ—¶æ³¨æ„ï¼Œå¦‚æžœä½ ä¸å–œæ¬¢ä½¿ç”¨å±žæ€§ï¼Œ ä½ å¯ä»¥ä½¿ç”¨åµŒå¥—çš„ <literal>&lt;formula&gt;</literal> æ˜ å°„å…ƒç´ ã€‚ "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Many-to-one"
-msgstr "多对一（many-to-one）"
+msgstr "多对一（many-to-one） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"An ordinary association to another persistent class is declared using a "
-"<literal>many-to-one</literal> element. The relational model is a many-to-"
-"one association; a foreign key in one table is referencing the primary key "
-"column(s) of the target table."
-msgstr ""
-"通过 <literal>many-to-one</literal> å…ƒç´ ,可以定义一种常见的与另一个持久化类的"
-"关联。这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外"
-"é”®å¼•ç”¨ç›®æ ‡è¡¨çš„ä¸»é”®å­—æ®µã€‚"
+#, no-c-format
+msgid "An ordinary association to another persistent class is declared using a <literal>many-to-one</literal> element. The relational model is a many-to-one association; a foreign key in one table is referencing the primary key column(s) of the target table."
+msgstr "通过 <literal>many-to-one</literal> å…ƒç´ ,å¯ä»¥å®šä¹‰ä¸€ç§å¸¸è§çš„ä¸Žå¦ä¸€ä¸ªæŒä¹…åŒ–ç±»çš„å…³è”ã€‚è¿™ç§å…³ç³»æ¨¡åž‹æ˜¯å¤šå¯¹ä¸€å…³è”ï¼ˆå®žé™…ä¸Šæ˜¯ä¸€ä¸ªå¯¹è±¡å¼•ç”¨ï¼è¯‘æ³¨ï¼‰ï¼šè¿™ä¸ªè¡¨çš„ä¸€ä¸ªå¤–é”®å¼•ç”¨ç›®æ ‡è¡¨çš„ä¸»é”®å­—æ®µã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>name</literal>: the name of the property."
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>name</literal>：属性的名称。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> (optional): the name of the foreign key column. "
-"This can also be specified by nested <literal>&lt;column&gt;</literal> "
-"element(s)."
-msgstr ""
-"<literal>column</literal>（可选）：外键字段的名称。也可以通过嵌套的  "
-"<literal>&lt;column&gt;</literal> 指定。"
+#, no-c-format
+msgid "<literal>column</literal> (optional): the name of the foreign key column. This can also be specified by nested <literal>&lt;column&gt;</literal> element(s)."
+msgstr "<literal>column</literal>（可选）：外键字段的名称。也可以通过嵌套的 <literal>&lt;column&gt;</literal> 指定。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal> (optional - defaults to the property type "
-"determined by reflection): the name of the associated class."
-msgstr ""
-"<literal>class</literal>（可选 — 默认是通过反射得到的属性类型）：被关联的类的"
-"名字。"
+#, no-c-format
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the name of the associated class."
+msgstr "<literal>class</literal>（可选 — 默认是通过反射得到的属性类型）：被关联的类的名字。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>cascade</literal> (optional): specifies which operations should be "
-"cascaded from the parent object to the associated object."
-msgstr ""
-"<literal>cascade（级联）</literal>（可选）表明操作是否从父对象级联到被关联的"
-"对象。"
+#, no-c-format
+msgid "<literal>cascade</literal> (optional): specifies which operations should be cascaded from the parent object to the associated object."
+msgstr "<literal>cascade（级联）</literal>（可选）表明操作是否从父对象级联到被关联的对象。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>fetch</literal> (optional - defaults to <literal>select</literal>): "
-"chooses between outer-join fetching or sequential select fetching."
-msgstr ""
-"<literal>fetch</literal>（可选 — 默认为 <literal>select</literal>）：在外连接"
-"抓取（outer-join fetching）和序列选择抓取（sequential select fetching）两者中"
-"选择其一。"
+#, no-c-format
+msgid "<literal>fetch</literal> (optional - defaults to <literal>select</literal>): chooses between outer-join fetching or sequential select fetching."
+msgstr "<literal>fetch</literal>（可选 — 默认为 <literal>select</literal>）：在外连接抓取（outer-join fetching）和序列选择抓取（sequential select fetching）两者中选择其一。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>update, insert</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that the mapped columns should be included in SQL "
-"<literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. "
-"Setting both to <literal>false</literal> allows a pure \"derived\" "
-"association whose value is initialized from another property that maps to "
-"the same column(s), or by a trigger or other application."
-msgstr ""
-"<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）指"
-"定对应的字段是否包含在用于 <literal>UPDATE</literal> 和/或 <literal>INSERT</"
-"literal> 的 SQL 语句中。如果二者都是<literal>false</literal>,则这是一个纯粹"
-"çš„ “外源性（derivedï¼‰â€å…³è”ï¼Œå®ƒçš„å€¼æ˜¯é€šè¿‡æ˜ å°„åˆ°åŒä¸€ä¸ªï¼ˆæˆ–å¤šä¸ªï¼‰å­—æ®µçš„æŸäº›å…¶ä»–"
-"属性得到 或者通过 trigger（触发器）、或其他程序生成。"
+#, no-c-format
+msgid "<literal>update, insert</literal> (optional - defaults to <literal>true</literal>): specifies that the mapped columns should be included in SQL <literal>UPDATE</literal> and/or <literal>INSERT</literal> statements. Setting both to <literal>false</literal> allows a pure \"derived\" association whose value is initialized from another property that maps to the same column(s), or by a trigger or other application."
+msgstr "<literal>update, insert</literal>（可选 — 默认为 <literal>true</literal>）指定对应的字段是否包含在用于 <literal>UPDATE</literal> å’Œ/或 <literal>INSERT</literal> çš„ SQL 语句中。如果二者都是<literal>false</literal>,则这是一个纯粹的 “外源性（derivedï¼‰â€å…³è”ï¼Œå®ƒçš„å€¼æ˜¯é€šè¿‡æ˜ å°„åˆ°åŒä¸€ä¸ªï¼ˆæˆ–å¤šä¸ªï¼‰å­—æ®µçš„æŸäº›å…¶ä»–å±žæ€§å¾—åˆ° 或者通过 trigger（触发器）、或其他程序生成。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>property-ref</literal> (optional): the name of a property of the "
-"associated class that is joined to this foreign key. If not specified, the "
-"primary key of the associated class is used."
-msgstr ""
-"<literal>property-ref</literal>：（可选）被关联到此外键的类中的对应属性的名"
-"字。如果没有指定，被关联类的主键将被使用。"
+#, no-c-format
+msgid "<literal>property-ref</literal> (optional): the name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used."
+msgstr "<literal>property-ref</literal>：（可选）被关联到此外键的类中的对应属性的名字。如果没有指定，被关联类的主键将被使用。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional): enables the DDL generation of a unique "
-"constraint for the foreign-key column. By allowing this to be the target of "
-"a <literal>property-ref</literal>, you can make the association multiplicity "
-"one-to-one."
-msgstr ""
-"<literal>unique</literal>（可选）：使用 DDL 为外键字段生成一个唯一约束。此"
-"外， 这也可以用作 <literal>property-ref</literal> çš„ç›®æ ‡å±žæ€§ã€‚è¿™ä½¿å…³è”åŒæ—¶å…·"
-"有一对一的效果。"
+#, no-c-format
+msgid "<literal>unique</literal> (optional): enables the DDL generation of a unique constraint for the foreign-key column. By allowing this to be the target of a <literal>property-ref</literal>, you can make the association multiplicity one-to-one."
+msgstr "<literal>unique</literal>（可选）：使用 DDL 为外键字段生成一个唯一约束。此外，这也可以用作 <literal>property-ref</literal> çš„ç›®æ ‡å±žæ€§ã€‚è¿™ä½¿å…³è”åŒæ—¶å…·æœ‰ä¸€å¯¹ä¸€çš„æ•ˆæžœã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>not-null</literal> (optional): enables the DDL generation of a "
-"nullability constraint for the foreign key columns."
-msgstr ""
-"<literal>not-null</literal>（可选）：使用 DDL 为外键字段生成一个非空约束。"
+#, no-c-format
+msgid "<literal>not-null</literal> (optional): enables the DDL generation of a nullability constraint for the foreign key columns."
+msgstr "<literal>not-null</literal>（可选）：使用 DDL 为外键字段生成一个非空约束。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): "
-"by default, single point associations are proxied. <literal>lazy=\"no-proxy"
-"\"</literal> specifies that the property should be fetched lazily when the "
-"instance variable is first accessed. This requires build-time bytecode "
-"instrumentation. <literal>lazy=\"false\"</literal> specifies that the "
-"association will always be eagerly fetched."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况"
-"下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal> 指定此属性应该"
-"在实例变量第一次被访问时应该延迟抓取（fetche lazilyï¼‰ï¼ˆéœ€è¦è¿è¡Œæ—¶å­—èŠ‚ç çš„å¢ž"
-"强）。<literal>lazy=\"false\"</literal> 指定此关联总是被预先抓取。"
+#, no-c-format
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): by default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed. This requires build-time bytecode instrumentation. <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched."
+msgstr "<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal> 指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazilyï¼‰ï¼ˆéœ€è¦è¿è¡Œæ—¶å­—èŠ‚ç çš„å¢žå¼ºï¼‰ã€‚<literal>lazy=\"false\"</literal> 指定此关联总是被预先抓取。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>not-found</literal> (optional - defaults to <literal>exception</"
-"literal>): specifies how foreign keys that reference missing rows will be "
-"handled. <literal>ignore</literal> will treat a missing row as a null "
-"association."
-msgstr ""
-"<literal>not-found</literal>（可选 - 默认为<literal>exception</literal>）：指"
-"定如何处理引用缺失行的外键：<literal>ignore</literal> 会把缺失的行作为一个空"
-"关联处理。"
+#, no-c-format
+msgid "<literal>not-found</literal> (optional - defaults to <literal>exception</literal>): specifies how foreign keys that reference missing rows will be handled. <literal>ignore</literal> will treat a missing row as a null association."
+msgstr "<literal>not-found</literal>（可选 - 默认为<literal>exception</literal>）：指定如何处理引用缺失行的外键：<literal>ignore</literal> 会把缺失的行作为一个空关联处理。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>entity-name</literal> (optional): the entity name of the associated "
-"class."
-msgstr "<literal>entity-name</literal>（可选）：被关联的类的实体名。"
+#, no-c-format
+msgid "<literal>entity-name</literal> (optional): the entity name of the associated class."
+msgstr "<literal>entity-name</literal>（可选）：被关联的类的实体名。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): an SQL expression that defines the "
-"value for a <emphasis>computed</emphasis> foreign key."
-msgstr ""
-"<literal>formula</literal>（可选）：SQL 表达式，用于定义 <emphasis>computed"
-"（计算出的）</emphasis>外键值。"
+msgid "<literal>formula</literal> (optional): an SQL expression that defines the value for a <emphasis>computed</emphasis> foreign key."
+msgstr "<literal>formula</literal>（可选）：SQL 表达式，用于定义 <emphasis>computed（计算出的）</emphasis>外键值。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Setting a value of the <literal>cascade</literal> attribute to any "
-"meaningful value other than <literal>none</literal> will propagate certain "
-"operations to the associated object. The meaningful values are divided into "
-"three categories. First, basic operations, which include: <literal>persist, "
-"merge, delete, save-update, evict, replicate, lock and refresh</literal>; "
-"second, special values: <literal>delete-orphan</literal>; and third,"
-"<literal>all</literal> comma-separated combinations of operation names: "
-"<literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,"
-"delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\" /> "
-"for a full explanation. Note that single valued, many-to-one and one-to-one, "
-"associations do not support orphan delete."
-msgstr ""
-"<literal>cascade</literal> 属性设置为除了<literal>none</literal> 以外任何有意"
-"ä¹‰çš„å€¼ï¼Œå®ƒå°†æŠŠç‰¹å®šçš„æ“ä½œä¼ é€’åˆ°å…³è”å¯¹è±¡ä¸­ã€‚è¿™ä¸ªå€¼å°±ä»£è¡¨ç€ Hibernate 基本操作的"
-"名称，<literal>persist, merge, delete, save-update, evict, replicate, lock, "
-"refresh</literal>，以及特别的值 <literal>delete-orphan</literal> 和 "
-"<literal>all</literal>，并且可以用逗号分隔符来组合这些操作，例如，"
-"<literal>cascade=\"persist,merge,evict\"</literal> 或  <literal>cascade="
-"\"all,delete-orphan\"</literal>。更全面的解释请参考 <xref linkend="
-"\"Working_with_objects-Transitive_persistence\"/>。注意，单值关联（many-to-"
-"one å’Œ one-to-one å…³è”ï¼‰ä¸æ”¯æŒåˆ é™¤å­¤å„¿ï¼ˆorphan deleteï¼Œåˆ é™¤ä¸å†è¢«å¼•ç”¨çš„å€¼ï¼‰ã€‚"
+#, no-c-format
+msgid "Setting a value of the <literal>cascade</literal> attribute to any meaningful value other than <literal>none</literal> will propagate certain operations to the associated object. The meaningful values are divided into three categories. First, basic operations, which include: <literal>persist, merge, delete, save-update, evict, replicate, lock and refresh</literal>; second, special values: <literal>delete-orphan</literal>; and third,<literal>all</literal> comma-separated combinations of operation names: <literal>cascade=\"persist,merge,evict\"</literal> or <literal>cascade=\"all,delete-orphan\"</literal>. See <xref linkend=\"objectstate-transitive\" /> for a full explanation. Note that single valued, many-to-one and one-to-one, associations do not support orphan delete."
+msgstr "<literal>cascade</literal> 属性设置为除了<literal>none</literal> ä»¥å¤–ä»»ä½•æœ‰æ„ä¹‰çš„å€¼ï¼Œå®ƒå°†æŠŠç‰¹å®šçš„æ“ä½œä¼ é€’åˆ°å…³è”å¯¹è±¡ä¸­ã€‚è¿™ä¸ªå€¼å°±ä»£è¡¨ç€ Hibernate 基本操作的名称，<literal>persist, merge, delete, save-update, evict, replicate, lock, refresh</literal>，以及特别的值 <literal>delete-orphan</literal> å’Œ <literal>all</literal>，并且可以用逗号分隔符来组合这些操作，例如，<literal>cascade=\"persist,merge,evict\"</literal> 或  <literal>cascade=\"all,delete-orphan\"</literal>。更全面的解释请参考 <xref linkend=\"objectstate-transitive\" />。注意，单值关联（many-to-one å’Œ one-to-one å…³è”ï¼‰ä¸æ”¯æŒåˆ é™¤å­¤å„¿ï¼ˆorphan deleteï¼Œåˆ é™¤ä¸å†è¢«å¼•ç”¨çš„å€¼ï¼‰ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Here is an example of a typical <literal>many-to-one</literal> declaration:"
-msgstr "一个典型的简单 <literal>many-to-one</literal> 定义例子："
+#, no-c-format
+msgid "Here is an example of a typical <literal>many-to-one</literal> declaration:"
+msgstr "一个典型的简单 <literal>many-to-one</literal> 定义例子： "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>property-ref</literal> attribute should only be used for "
-"mapping legacy data where a foreign key refers to a unique key of the "
-"associated table other than the primary key. This is a complicated and "
-"confusing relational model. For example, if the <literal>Product</literal> "
-"class had a unique serial number that is not the primary key. The "
-"<literal>unique</literal> attribute controls Hibernate's DDL generation with "
-"the SchemaExport tool."
-msgstr ""
-"<literal>property-ref</literal> 属性只应该用来对付遗留下来的数据库系统，可能"
-"有外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况下。这"
-"是一种十分丑陋的关系模型。比如说，假设 <literal>Product</literal> 类有一个惟"
-"一的序列号，它并不是主键。（<literal>unique</literal> 属性控制 Hibernate 通"
-"过 SchemaExport 工具进行的 DDL 生成。）"
+#, no-c-format
+msgid "The <literal>property-ref</literal> attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key. This is a complicated and confusing relational model. For example, if the <literal>Product</literal> class had a unique serial number that is not the primary key. The <literal>unique</literal> attribute controls Hibernate's DDL generation with the SchemaExport tool."
+msgstr "<literal>property-ref</literal> 属性只应该用来对付遗留下来的数据库系统，可能有外键指向对方关联表的是个非主键字段（但是应该是一个惟一关键字）的情况下。这是一种十分丑陋的关系模型。比如说，假设 <literal>Product</literal> 类有一个惟一的序列号，它并不是主键。（<literal>unique</literal> 属性控制 Hibernate 通过 SchemaExport 工具进行的 DDL 生成。） "
 
 #. Tag: para
 #, no-c-format
@@ -2273,103 +1116,54 @@
 msgstr "那么关于 <literal>OrderItem</literal> çš„æ˜ å°„å¯èƒ½æ˜¯ï¼š"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "This is not encouraged, however."
-msgstr "当然，我们决不鼓励这种用法。"
+msgstr "当然，我们并不鼓励这种用法。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If the referenced unique key comprises multiple properties of the associated "
-"entity, you should map the referenced properties inside a named <literal>&lt;"
-"properties&gt;</literal> element."
-msgstr ""
-"å¦‚æžœè¢«å¼•ç”¨çš„å”¯ä¸€ä¸»é”®ç”±å…³è”å®žä½“çš„å¤šä¸ªå±žæ€§ç»„æˆï¼Œä½ åº”è¯¥åœ¨åç§°ä¸º <literal>&lt;"
-"properties&gt;</literal> çš„å…ƒç´  é‡Œé¢æ˜ å°„æ‰€æœ‰å…³è”çš„å±žæ€§ã€‚"
+msgid "If the referenced unique key comprises multiple properties of the associated entity, you should map the referenced properties inside a named <literal>&lt;properties&gt;</literal> element."
+msgstr "å¦‚æžœè¢«å¼•ç”¨çš„å”¯ä¸€ä¸»é”®ç”±å…³è”å®žä½“çš„å¤šä¸ªå±žæ€§ç»„æˆï¼Œä½ åº”è¯¥åœ¨åç§°ä¸º <literal>&lt;properties&gt;</literal> çš„å…ƒç´  é‡Œé¢æ˜ å°„æ‰€æœ‰å…³è”çš„å±žæ€§ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If the referenced unique key is the property of a component, you can specify "
-"a property path:"
-msgstr "å‡è‹¥è¢«å¼•ç”¨çš„å”¯ä¸€ä¸»é”®æ˜¯ç»„ä»¶çš„å±žæ€§ï¼Œä½ å¯ä»¥æŒ‡å®šå±žæ€§è·¯å¾„ï¼š"
+#, no-c-format
+msgid "If the referenced unique key is the property of a component, you can specify a property path:"
+msgstr "å‡è‹¥è¢«å¼•ç”¨çš„å”¯ä¸€ä¸»é”®æ˜¯ç»„ä»¶çš„å±žæ€§ï¼Œä½ å¯ä»¥æŒ‡å®šå±žæ€§è·¯å¾„ï¼š "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "One-to-one"
-msgstr "一对一"
+msgstr "一对一 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A one-to-one association to another persistent class is declared using a "
-"<literal>one-to-one</literal> element."
-msgstr ""
-"持久化对象之间一对一的关联关系是通过 <literal>one-to-one</literal> å…ƒç´ å®šä¹‰"
-"的。"
+msgid "A one-to-one association to another persistent class is declared using a <literal>one-to-one</literal> element."
+msgstr "持久化对象之间一对一的关联关系是通过 <literal>one-to-one</literal> å…ƒç´ å®šä¹‰çš„ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>constrained</literal> (optional): specifies that a foreign key "
-"constraint on the primary key of the mapped table and references the table "
-"of the associated class. This option affects the order in which <literal>save"
-"()</literal> and <literal>delete()</literal> are cascaded, and determines "
-"whether the association can be proxied. It is also used by the schema export "
-"tool."
-msgstr ""
-"<literal>constrained（约束）</literal>（可选）表明该类对应的表对应的数据库"
-"表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个"
-"选项影响 <literal>save()</literal> 和 <literal>delete()</literal> 在级联执行"
-"时的先后顺序以及决定该关联能否被委托（也在 schema export tool 中被使用）。"
+#, no-c-format
+msgid "<literal>constrained</literal> (optional): specifies that a foreign key constraint on the primary key of the mapped table and references the table of the associated class. This option affects the order in which <literal>save()</literal> and <literal>delete()</literal> are cascaded, and determines whether the association can be proxied. It is also used by the schema export tool."
+msgstr "<literal>constrained（约束）</literal>（可选）表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响 <literal>save()</literal> 和 <literal>delete()</literal> 在级联执行时的先后顺序以及决定该关联能否被委托（也在 schema export tool 中被使用）。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>property-ref</literal> (optional): the name of a property of the "
-"associated class that is joined to the primary key of this class. If not "
-"specified, the primary key of the associated class is used."
-msgstr ""
-"<literal>property-ref</literal>：（可选）指定关联类的属性名，这个属性将会和本"
-"类的主键相对应。如果没有指定，会使用对方关联类的主键。"
+#, no-c-format
+msgid "<literal>property-ref</literal> (optional): the name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used."
+msgstr "<literal>property-ref</literal>：（可选）指定关联类的属性名，这个属性将会和本类的主键相对应。如果没有指定，会使用对方关联类的主键。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>formula</literal> (optional): almost all one-to-one associations "
-"map to the primary key of the owning entity. If this is not the case, you "
-"can specify another column, columns or expression to join on using an SQL "
-"formula. See <literal>org.hibernate.test.onetooneformula</literal> for an "
-"example."
-msgstr ""
-"<literal>formula </literal>（可选）：绝大多数一对一的关联都指向其实体的主键。"
-"åœ¨ä¸€äº›å°‘è§çš„æƒ…å†µä¸­ï¼Œä½ å¯èƒ½ä¼šæŒ‡å‘å…¶ä»–çš„ä¸€ä¸ªæˆ–å¤šä¸ªå­—æ®µï¼Œæˆ–è€…æ˜¯ä¸€ä¸ªè¡¨è¾¾å¼ï¼Œè¿™äº›"
-"æƒ…å†µä¸‹ï¼Œä½ å¯ä»¥ç”¨ä¸€ä¸ª SQL 公式来表示。（可以在 org.hibernate.test."
-"onetooneformula 找到例子）"
+#, no-c-format
+msgid "<literal>formula</literal> (optional): almost all one-to-one associations map to the primary key of the owning entity. If this is not the case, you can specify another column, columns or expression to join on using an SQL formula. See <literal>org.hibernate.test.onetooneformula</literal> for an example."
+msgstr "<literal>formula </literal>ï¼ˆå¯é€‰ï¼‰ï¼šç»å¤§å¤šæ•°ä¸€å¯¹ä¸€çš„å…³è”éƒ½æŒ‡å‘å…¶å®žä½“çš„ä¸»é”®ã€‚åœ¨ä¸€äº›å°‘è§çš„æƒ…å†µä¸­ï¼Œä½ å¯èƒ½ä¼šæŒ‡å‘å…¶ä»–çš„ä¸€ä¸ªæˆ–å¤šä¸ªå­—æ®µï¼Œæˆ–è€…æ˜¯ä¸€ä¸ªè¡¨è¾¾å¼ï¼Œè¿™äº›æƒ…å†µä¸‹ï¼Œä½ å¯ä»¥ç”¨ä¸€ä¸ª SQL 公式来表示。（可以在 org.hibernate.test.onetooneformula 找到例子） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): "
-"by default, single point associations are proxied. <literal>lazy=\"no-proxy"
-"\"</literal> specifies that the property should be fetched lazily when the "
-"instance variable is first accessed. It requires build-time bytecode "
-"instrumentation. <literal>lazy=\"false\"</literal> specifies that the "
-"association will always be eagerly fetched. <emphasis>Note that if "
-"<literal>constrained=\"false\"</literal>, proxying is impossible and "
-"Hibernate will eagerly fetch the association</emphasis>."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况"
-"下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal>指定此属性应该"
-"在实例变量第一次被访问时应该延迟抓取（fetche lazilyï¼‰ï¼ˆéœ€è¦è¿è¡Œæ—¶å­—èŠ‚ç çš„å¢ž"
-"强）。 <literal>lazy=\"false\"</literal>指定此关联总是被预先抓取。<emphasis>"
-"注意，如果<literal>constrained=\"false\"</literal>, 不可能使用代理，Hibernate"
-"会采取预先抓取！</emphasis>"
+#, no-c-format
+msgid "<literal>lazy</literal> (optional - defaults to <literal>proxy</literal>): by default, single point associations are proxied. <literal>lazy=\"no-proxy\"</literal> specifies that the property should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation. <literal>lazy=\"false\"</literal> specifies that the association will always be eagerly fetched. <emphasis>Note that if <literal>constrained=\"false\"</literal>, proxying is impossible and Hibernate will eagerly fetch the association</emphasis>."
+msgstr "<literal>lazy</literal>（可选 — 默认为 <literal>proxy</literal>）：默认情况下，单点关联是经过代理的。<literal>lazy=\"no-proxy\"</literal>指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazilyï¼‰ï¼ˆéœ€è¦è¿è¡Œæ—¶å­—èŠ‚ç çš„å¢žå¼ºï¼‰ã€‚ <literal>lazy=\"false\"</literal>指定此关联总是被预先抓取。<emphasis>注意，如果 <literal>constrained=\"false\"</literal>, 不可能使用代理，Hibernate会采取预先抓取！</emphasis>。"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "There are two varieties of one-to-one associations:"
-msgstr "有两种不同的一对一关联："
+msgstr "有两种不同的一对一关联： "
 
 #. Tag: para
 #, no-c-format
@@ -2382,221 +1176,114 @@
 msgstr "惟一外键关联"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Primary key associations do not need an extra table column. If two rows are "
-"related by the association, then the two table rows share the same primary "
-"key value. To relate two objects by a primary key association, ensure that "
-"they are assigned the same identifier value."
-msgstr ""
-"主键关联不需要额外的表字段；如果两行是通过这种一对一关系相关联的，那么这两行"
-"å°±å…±äº«åŒæ ·çš„ä¸»å…³é”®å­—å€¼ã€‚æ‰€ä»¥å¦‚æžœä½ å¸Œæœ›ä¸¤ä¸ªå¯¹è±¡é€šè¿‡ä¸»é”®ä¸€å¯¹ä¸€å…³è”ï¼Œä½ å¿…é¡»ç¡®è®¤"
-"å®ƒä»¬è¢«èµ‹äºˆåŒæ ·çš„æ ‡è¯†å€¼ï¼"
+#, no-c-format
+msgid "Primary key associations do not need an extra table column. If two rows are related by the association, then the two table rows share the same primary key value. To relate two objects by a primary key association, ensure that they are assigned the same identifier value."
+msgstr "ä¸»é”®å…³è”ä¸éœ€è¦é¢å¤–çš„è¡¨å­—æ®µï¼›å¦‚æžœä¸¤è¡Œæ˜¯é€šè¿‡è¿™ç§ä¸€å¯¹ä¸€å…³ç³»ç›¸å…³è”çš„ï¼Œé‚£ä¹ˆè¿™ä¸¤è¡Œå°±å…±äº«åŒæ ·çš„ä¸»å…³é”®å­—å€¼ã€‚æ‰€ä»¥å¦‚æžœä½ å¸Œæœ›ä¸¤ä¸ªå¯¹è±¡é€šè¿‡ä¸»é”®ä¸€å¯¹ä¸€å…³è”ï¼Œä½ å¿…é¡»ç¡®è®¤å®ƒä»¬è¢«èµ‹äºˆåŒæ ·çš„æ ‡è¯†å€¼ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For a primary key association, add the following mappings to "
-"<literal>Employee</literal> and <literal>Person</literal> respectively:"
-msgstr ""
-"比如说，对下面的 <literal>Employee</literal> 和 <literal>Person</literal> 进"
-"行主键一对一关联:"
+#, no-c-format
+msgid "For a primary key association, add the following mappings to <literal>Employee</literal> and <literal>Person</literal> respectively:"
+msgstr "比如说，对下面的 <literal>Employee</literal> 和 <literal>Person</literal> 进行主键一对一关联："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Ensure that the primary keys of the related rows in the PERSON and EMPLOYEE "
-"tables are equal. You use a special Hibernate identifier generation strategy "
-"called <literal>foreign</literal>:"
-msgstr ""
-"现在我们必须确保 PERSON 和 EMPLOYEE 中相关的字段是相等的。我们使用一个被成为 "
-"<literal>foreign</literal> 的特殊的 hibernate æ ‡è¯†ç¬¦ç”Ÿæˆç­–ç•¥ï¼š"
+#, no-c-format
+msgid "Ensure that the primary keys of the related rows in the PERSON and EMPLOYEE tables are equal. You use a special Hibernate identifier generation strategy called <literal>foreign</literal>:"
+msgstr "现在我们必须确保 PERSON å’Œ EMPLOYEE 中相关的字段是相等的。我们使用一个被成为 <literal>foreign</literal> 的特殊的 hibernate æ ‡è¯†ç¬¦ç”Ÿæˆç­–ç•¥ï¼š "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A newly saved instance of <literal>Person</literal> is assigned the same "
-"primary key value as the <literal>Employee</literal> instance referred with "
-"the <literal>employee</literal> property of that <literal>Person</literal>."
-msgstr ""
-"一个刚刚保存的 <literal>Person</literal> 实例被赋予和该 <literal>Person</"
-"literal> 的 <literal>employee</literal> 属性所指向的 <literal>Employee</"
-"literal> å®žä¾‹åŒæ ·çš„å…³é”®å­—å€¼ã€‚"
+#, no-c-format
+msgid "A newly saved instance of <literal>Person</literal> is assigned the same primary key value as the <literal>Employee</literal> instance referred with the <literal>employee</literal> property of that <literal>Person</literal>."
+msgstr "一个刚刚保存的 <literal>Person</literal> 实例被赋予和该 <literal>Person</literal> çš„ <literal>employee</literal> 属性所指向的 <literal>Employee</literal> å®žä¾‹åŒæ ·çš„å…³é”®å­—å€¼ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Alternatively, a foreign key with a unique constraint, from "
-"<literal>Employee</literal> to <literal>Person</literal>, can be expressed "
-"as:"
-msgstr ""
-"另一种方式是一个外键和一个惟一关键字对应，上面的 <literal>Employee</literal> "
-"和  <literal>Person</literal> 的例子，如果使用这种关联方式，可以表达成："
+#, no-c-format
+msgid "Alternatively, a foreign key with a unique constraint, from <literal>Employee</literal> to <literal>Person</literal>, can be expressed as:"
+msgstr "另一种方式是一个外键和一个惟一关键字对应，上面的 <literal>Employee</literal> 和  <literal>Person</literal> 的例子，如果使用这种关联方式，可以表达成： "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This association can be made bidirectional by adding the following to the "
-"<literal>Person</literal> mapping:"
-msgstr ""
-"如果在 <literal>Person</literal> çš„æ˜ å°„åŠ å…¥ä¸‹é¢å‡ å¥ï¼Œè¿™ç§å…³è”å°±æ˜¯åŒå‘çš„ï¼š"
+#, no-c-format
+msgid "This association can be made bidirectional by adding the following to the <literal>Person</literal> mapping:"
+msgstr "如果在 <literal>Person</literal> çš„æ˜ å°„åŠ å…¥ä¸‹é¢å‡ å¥ï¼Œè¿™ç§å…³è”å°±æ˜¯åŒå‘çš„ï¼š "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Natural-id"
-msgstr "自然 ID（natural-id）"
+msgstr "自然 ID（natural-id） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Although we recommend the use of surrogate keys as primary keys, you should "
-"try to identify natural keys for all entities. A natural key is a property "
-"or combination of properties that is unique and non-null. It is also "
-"immutable. Map the properties of the natural key inside the <literal>&lt;"
-"natural-id&gt;</literal> element. Hibernate will generate the necessary "
-"unique key and nullability constraints and, as a result, your mapping will "
-"be more self-documenting."
-msgstr ""
-"我们建议使用代用键（键值不具备实际意义）作为主键，我们仍然应该尝试为所有的实"
-"ä½“é‡‡ç”¨è‡ªç„¶çš„é”®å€¼ä½œä¸ºï¼ˆé™„åŠ â€”â€”è¯‘è€…æ³¨ï¼‰æ ‡ç¤ºã€‚è‡ªç„¶é”®ï¼ˆnatural key）是单个或组合属"
-"性，他们必须唯一且非空。如果它还是不可变的那就更理想了。在 <literal>&lt;"
-"natural-id&gt;</literal> å…ƒç´ ä¸­åˆ—å‡ºè‡ªç„¶é”®çš„å±žæ€§ã€‚Hibernate ä¼šå¸®ä½ ç”Ÿæˆå¿…é¡»çš„å”¯"
-"ä¸€é”®å€¼å’Œéžç©ºçº¦æŸï¼Œä½ çš„æ˜ å°„ä¼šæ›´åŠ çš„æ˜Žæ˜¾æ˜“æ‡‚ï¼ˆåŽŸæ–‡æ˜¯ self-documenting，自我注"
-"解）。"
+#, no-c-format
+msgid "Although we recommend the use of surrogate keys as primary keys, you should try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. It is also immutable. Map the properties of the natural key inside the <literal>&lt;natural-id&gt;</literal> element. Hibernate will generate the necessary unique key and nullability constraints and, as a result, your mapping will be more self-documenting."
+msgstr "æˆ‘ä»¬å»ºè®®ä½¿ç”¨ä»£ç”¨é”®ï¼ˆé”®å€¼ä¸å…·å¤‡å®žé™…æ„ä¹‰ï¼‰ä½œä¸ºä¸»é”®ï¼Œæˆ‘ä»¬ä»ç„¶åº”è¯¥å°è¯•ä¸ºæ‰€æœ‰çš„å®žä½“é‡‡ç”¨è‡ªç„¶çš„é”®å€¼ä½œä¸ºï¼ˆé™„åŠ â€”â€”è¯‘è€…æ³¨ï¼‰æ ‡ç¤ºã€‚è‡ªç„¶é”®ï¼ˆnatural key）是单个或组合属性，他们必须唯一且非空。如果它还是不可变的那就更理想了。在 <literal>&lt;natural-id&gt;</literal> å…ƒç´ ä¸­åˆ—å‡ºè‡ªç„¶é”®çš„å±žæ€§ã€‚Hibernate ä¼šå¸®ä½ ç”Ÿæˆå¿…é¡»çš„å”¯ä¸€é”®å€¼å’Œéžç©ºçº¦æŸï¼Œä½ çš„æ˜ å°„ä¼šæ›´åŠ çš„æ˜Žæ˜¾æ˜“æ‡‚ï¼ˆåŽŸæ–‡æ˜¯ self-documenting，自我注解）。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is recommended that you implement <literal>equals()</literal> and "
-"<literal>hashCode()</literal> to compare the natural key properties of the "
-"entity."
-msgstr ""
-"æˆ‘ä»¬å¼ºçƒˆå»ºè®®ä½ å®žçŽ° <literal>equals()</literal> å’Œ <literal>hashCode()</"
-"literal> 方法,来比较实体的自然键属性。"
+#, no-c-format
+msgid "It is recommended that you implement <literal>equals()</literal> and <literal>hashCode()</literal> to compare the natural key properties of the entity."
+msgstr "æˆ‘ä»¬å¼ºçƒˆå»ºè®®ä½ å®žçŽ° <literal>equals()</literal> å’Œ <literal>hashCode()</literal> 方法,来比较实体的自然键属性。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This mapping is not intended for use with entities that have natural primary "
-"keys."
-msgstr "è¿™ä¸€æ˜ å°„ä¸æ˜¯ä¸ºäº†æŠŠè‡ªç„¶é”®ä½œä¸ºä¸»é”®è€Œå‡†å¤‡çš„ã€‚"
+#, no-c-format
+msgid "This mapping is not intended for use with entities that have natural primary keys."
+msgstr "è¿™ä¸€æ˜ å°„ä¸æ˜¯ä¸ºäº†æŠŠè‡ªç„¶é”®ä½œä¸ºä¸»é”®è€Œå‡†å¤‡çš„ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>mutable</literal> (optional - defaults to <literal>false</"
-"literal>): by default, natural identifier properties are assumed to be "
-"immutable (constant)."
-msgstr ""
-"<literal>mutable</literal>（可选，默认为 <literal>false</literal>）：默认情况"
-"ä¸‹ï¼Œè‡ªç„¶æ ‡è¯†å±žæ€§è¢«å‡å®šä¸ºä¸å¯å˜çš„ï¼ˆå¸¸é‡ï¼‰ã€‚"
+#, no-c-format
+msgid "<literal>mutable</literal> (optional - defaults to <literal>false</literal>): by default, natural identifier properties are assumed to be immutable (constant)."
+msgstr "<literal>mutable</literal>（可选，默认为 <literal>false</literal>ï¼‰ï¼šé»˜è®¤æƒ…å†µä¸‹ï¼Œè‡ªç„¶æ ‡è¯†å±žæ€§è¢«å‡å®šä¸ºä¸å¯å˜çš„ï¼ˆå¸¸é‡ï¼‰ã€‚ "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Component and dynamic-component"
-msgstr "组件（component），动态组件（dynamic-component）"
+msgstr "组件（component），动态组件（dynamic-component） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>&lt;component&gt;</literal> element maps properties of a child "
-"object to columns of the table of a parent class. Components can, in turn, "
-"declare their own properties, components or collections. See the \"Component"
-"\" examples below:"
-msgstr ""
-"<literal>&lt;component&gt;</literal> å…ƒç´ æŠŠå­å¯¹è±¡çš„ä¸€äº›å…ƒç´ ä¸Žçˆ¶ç±»å¯¹åº”çš„è¡¨çš„ä¸€"
-"äº›å­—æ®µæ˜ å°„èµ·æ¥ã€‚ç„¶åŽç»„ä»¶å¯ä»¥å®šä¹‰å®ƒä»¬è‡ªå·±çš„å±žæ€§ã€ç»„ä»¶æˆ–è€…é›†åˆã€‚å‚è§åŽé¢"
-"的“Componentsâ€ä¸€ç« ã€‚"
+#, no-c-format
+msgid "The <literal>&lt;component&gt;</literal> element maps properties of a child object to columns of the table of a parent class. Components can, in turn, declare their own properties, components or collections. See the \"Component\" examples below:"
+msgstr "<literal>&lt;component&gt;</literal> å…ƒç´ æŠŠå­å¯¹è±¡çš„ä¸€äº›å…ƒç´ ä¸Žçˆ¶ç±»å¯¹åº”çš„è¡¨çš„ä¸€äº›å­—æ®µæ˜ å°„èµ·æ¥ã€‚ç„¶åŽç»„ä»¶å¯ä»¥å®šä¹‰å®ƒä»¬è‡ªå·±çš„å±žæ€§ã€ç»„ä»¶æˆ–è€…é›†åˆã€‚å‚è§åŽé¢çš„â€œComponentsâ€ä¸€ç« ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal> (optional - defaults to the property type "
-"determined by reflection): the name of the component (child) class."
-msgstr ""
-"<literal>class</literal>（可选 — 默认为通过反射得到的属性类型）：组件（子）类"
-"的名字。"
+#, no-c-format
+msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the name of the component (child) class."
+msgstr "<literal>class</literal>（可选 — 默认为通过反射得到的属性类型）：组件（子）类的名字。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>insert</literal>: do the mapped columns appear in SQL "
-"<literal>INSERTs</literal>?"
-msgstr ""
-"<literal>insert</literal>ï¼šè¢«æ˜ å°„çš„å­—æ®µæ˜¯å¦å‡ºçŽ°åœ¨ SQL çš„ <literal>INSERT</"
-"literal> 语句中？"
+#, no-c-format
+msgid "<literal>insert</literal>: do the mapped columns appear in SQL <literal>INSERTs</literal>?"
+msgstr "<literal>insert</literal>ï¼šè¢«æ˜ å°„çš„å­—æ®µæ˜¯å¦å‡ºçŽ°åœ¨ SQL çš„ <literal>INSERT</literal> 语句中？ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>update</literal>: do the mapped columns appear in SQL "
-"<literal>UPDATEs</literal>?"
-msgstr ""
-"<literal>update</literal>ï¼šè¢«æ˜ å°„çš„å­—æ®µæ˜¯å¦å‡ºçŽ°åœ¨ SQL çš„ <literal>UPDATE</"
-"literal> 语句中？"
+#, no-c-format
+msgid "<literal>update</literal>: do the mapped columns appear in SQL <literal>UPDATEs</literal>?"
+msgstr "<literal>update</literal>ï¼šè¢«æ˜ å°„çš„å­—æ®µæ˜¯å¦å‡ºçŽ°åœ¨ SQL çš„ <literal>UPDATE</literal> 语句中？ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>false</literal>): "
-"specifies that this component should be fetched lazily when the instance "
-"variable is first accessed. It requires build-time bytecode instrumentation."
-msgstr ""
-"<literal>lazy</literal>（可选 — 默认是 <literal>false</literal>）：表明此组件"
-"åº”åœ¨å®žä¾‹å˜é‡ç¬¬ä¸€æ¬¡è¢«è®¿é—®çš„æ—¶å€™å»¶è¿ŸåŠ è½½ï¼ˆéœ€è¦ç¼–è¯‘æ—¶å­—èŠ‚ç è£…ç½®å™¨ï¼‰"
+#, no-c-format
+msgid "<literal>lazy</literal> (optional - defaults to <literal>false</literal>): specifies that this component should be fetched lazily when the instance variable is first accessed. It requires build-time bytecode instrumentation."
+msgstr "<literal>lazy</literal>（可选 — 默认是 <literal>false</literal>ï¼‰ï¼šè¡¨æ˜Žæ­¤ç»„ä»¶åº”åœ¨å®žä¾‹å˜é‡ç¬¬ä¸€æ¬¡è¢«è®¿é—®çš„æ—¶å€™å»¶è¿ŸåŠ è½½ï¼ˆéœ€è¦ç¼–è¯‘æ—¶å­—èŠ‚ç è£…ç½®å™¨ï¼‰ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to this component either do or do not "
-"require acquisition of the optimistic lock. It determines if a version "
-"increment should occur when this property is dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）："
-"è¡¨æ˜Žæ›´æ–°æ­¤ç»„ä»¶æ˜¯å¦éœ€è¦èŽ·å–ä¹è§‚é”ã€‚æ¢å¥è¯è¯´ï¼Œå½“è¿™ä¸ªå±žæ€§å˜è„æ—¶ï¼Œæ˜¯å¦å¢žåŠ ç‰ˆæœ¬å·"
-"（Version）"
+#, no-c-format
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to this component either do or do not require acquisition of the optimistic lock. It determines if a version increment should occur when this property is dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>ï¼‰ï¼šè¡¨æ˜Žæ›´æ–°æ­¤ç»„ä»¶æ˜¯å¦éœ€è¦èŽ·å–ä¹è§‚é”ã€‚æ¢å¥è¯è¯´ï¼Œå½“è¿™ä¸ªå±žæ€§å˜è„æ—¶ï¼Œæ˜¯å¦å¢žåŠ ç‰ˆæœ¬å·ï¼ˆVersion） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional - defaults to <literal>false</literal>): "
-"specifies that a unique constraint exists upon all mapped columns of the "
-"component."
-msgstr ""
-"<literal>unique</literal>（可选 — 默认是 <literal>false</literal>）：表明组件"
-"æ˜ å°„çš„æ‰€æœ‰å­—æ®µä¸Šéƒ½æœ‰å”¯ä¸€æ€§çº¦æŸ"
+#, no-c-format
+msgid "<literal>unique</literal> (optional - defaults to <literal>false</literal>): specifies that a unique constraint exists upon all mapped columns of the component."
+msgstr "<literal>unique</literal>（可选 — 默认是 <literal>false</literal>ï¼‰ï¼šè¡¨æ˜Žç»„ä»¶æ˜ å°„çš„æ‰€æœ‰å­—æ®µä¸Šéƒ½æœ‰å”¯ä¸€æ€§çº¦æŸ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The child <literal>&lt;property&gt;</literal> tags map properties of the "
-"child class to table columns."
-msgstr ""
-"å…¶ <literal>&lt;property&gt;</literal> å­æ ‡ç­¾ä¸ºå­ç±»çš„ä¸€äº›å±žæ€§ä¸Žè¡¨å­—æ®µä¹‹é—´å»ºç«‹"
-"æ˜ å°„ã€‚"
+msgid "The child <literal>&lt;property&gt;</literal> tags map properties of the child class to table columns."
+msgstr "å…¶ <literal>&lt;property&gt;</literal> å­æ ‡ç­¾ä¸ºå­ç±»çš„ä¸€äº›å±žæ€§ä¸Žè¡¨å­—æ®µä¹‹é—´å»ºç«‹æ˜ å°„ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;"
-"parent&gt;</literal> subelement that maps a property of the component class "
-"as a reference back to the containing entity."
-msgstr ""
-"<literal>&lt;component&gt;</literal> å…ƒç´ å…è®¸åŠ å…¥ä¸€ä¸ª <literal>&lt;parent&gt;"
-"</literal> å­å…ƒç´ ï¼Œåœ¨ç»„ä»¶ç±»å†…éƒ¨å°±å¯ä»¥æœ‰ä¸€ä¸ªæŒ‡å‘å…¶å®¹å™¨çš„å®žä½“çš„åå‘å¼•ç”¨ã€‚"
+msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "<literal>&lt;component&gt;</literal> å…ƒç´ å…è®¸åŠ å…¥ä¸€ä¸ª <literal>&lt;parent&gt;</literal> å­å…ƒç´ ï¼Œåœ¨ç»„ä»¶ç±»å†…éƒ¨å°±å¯ä»¥æœ‰ä¸€ä¸ªæŒ‡å‘å…¶å®¹å™¨çš„å®žä½“çš„åå‘å¼•ç”¨ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>&lt;dynamic-component&gt;</literal> element allows a "
-"<literal>Map</literal> to be mapped as a component, where the property names "
-"refer to keys of the map. See <xref linkend=\"components-dynamic\" /> for "
-"more information."
-msgstr ""
-"<literal>&lt;dynamic-component&gt;</literal> å…ƒç´ å…è®¸æŠŠä¸€ä¸ª <literal>Map</"
-"literal> æ˜ å°„ä¸ºç»„ä»¶ï¼Œå…¶å±žæ€§åå¯¹åº” map 的键值。参见 <xref linkend="
-"\"Component_Mapping-Dynamic_components\"/>。"
+#, no-c-format
+msgid "The <literal>&lt;dynamic-component&gt;</literal> element allows a <literal>Map</literal> to be mapped as a component, where the property names refer to keys of the map. See <xref linkend=\"components-dynamic\" /> for more information."
+msgstr "<literal>&lt;dynamic-component&gt;</literal> å…ƒç´ å…è®¸æŠŠä¸€ä¸ª <literal>Map</literal> æ˜ å°„ä¸ºç»„ä»¶ï¼Œå…¶å±žæ€§åå¯¹åº” map 的键值。参见 <xref linkend=\"components-dynamic\" />。"
 
 #. Tag: title
 #, no-c-format
@@ -2604,488 +1291,254 @@
 msgstr "属性（Properties）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>&lt;properties&gt;</literal> element allows the definition of a "
-"named, logical grouping of the properties of a class. The most important use "
-"of the construct is that it allows a combination of properties to be the "
-"target of a <literal>property-ref</literal>. It is also a convenient way to "
-"define a multi-column unique constraint. For example:"
-msgstr ""
-"<literal>&lt;properties&gt;</literal> å…ƒç´ å…è®¸å®šä¹‰ä¸€ä¸ªå‘½åçš„é€»è¾‘åˆ†ç»„"
-"（groupingï¼‰åŒ…å«ä¸€ä¸ªç±»ä¸­çš„å¤šä¸ªå±žæ€§ã€‚è¿™ä¸ªå…ƒç´ æœ€é‡è¦çš„ç”¨å¤„æ˜¯å…è®¸å¤šä¸ªå±žæ€§çš„ç»„åˆ"
-"作为 <literal>property-ref</literal> çš„ç›®æ ‡ï¼ˆtarget）。这也是定义多字段唯一约"
-"束的一种方便途径。"
+#, no-c-format
+msgid "The <literal>&lt;properties&gt;</literal> element allows the definition of a named, logical grouping of the properties of a class. The most important use of the construct is that it allows a combination of properties to be the target of a <literal>property-ref</literal>. It is also a convenient way to define a multi-column unique constraint. For example:"
+msgstr "<literal>&lt;properties&gt;</literal> å…ƒç´ å…è®¸å®šä¹‰ä¸€ä¸ªå‘½åçš„é€»è¾‘åˆ†ç»„ï¼ˆgroupingï¼‰åŒ…å«ä¸€ä¸ªç±»ä¸­çš„å¤šä¸ªå±žæ€§ã€‚è¿™ä¸ªå…ƒç´ æœ€é‡è¦çš„ç”¨å¤„æ˜¯å…è®¸å¤šä¸ªå±žæ€§çš„ç»„åˆä½œä¸º <literal>property-ref</literal> çš„ç›®æ ‡ï¼ˆtarget）。这也是定义多字段唯一约束的一种方便途径。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>name</literal>: the logical name of the grouping. It is "
-"<emphasis>not</emphasis> an actual property name."
-msgstr ""
-"<literal>name</literal>：分组的逻辑名称 — <emphasis>不是</emphasis> 实际属性"
-"的名称。"
+#, no-c-format
+msgid "<literal>name</literal>: the logical name of the grouping. It is <emphasis>not</emphasis> an actual property name."
+msgstr "<literal>name</literal>：分组的逻辑名称 — <emphasis>不是</emphasis> 实际属性的名称。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to these properties either do or do not "
-"require acquisition of the optimistic lock. It determines if a version "
-"increment should occur when these properties are dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）："
-"è¡¨æ˜Žæ›´æ–°æ­¤ç»„ä»¶æ˜¯å¦éœ€è¦èŽ·å–ä¹è§‚é”ã€‚æ¢å¥è¯è¯´ï¼Œå½“è¿™ä¸ªå±žæ€§å˜è„æ—¶ï¼Œæ˜¯å¦å¢žåŠ ç‰ˆæœ¬å·"
-"（Version）"
+#, no-c-format
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to these properties either do or do not require acquisition of the optimistic lock. It determines if a version increment should occur when these properties are dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>ï¼‰ï¼šè¡¨æ˜Žæ›´æ–°æ­¤ç»„ä»¶æ˜¯å¦éœ€è¦èŽ·å–ä¹è§‚é”ã€‚æ¢å¥è¯è¯´ï¼Œå½“è¿™ä¸ªå±žæ€§å˜è„æ—¶ï¼Œæ˜¯å¦å¢žåŠ ç‰ˆæœ¬å·ï¼ˆVersion）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For example, if we have the following <literal>&lt;properties&gt;</literal> "
-"mapping:"
+msgid "For example, if we have the following <literal>&lt;properties&gt;</literal> mapping:"
 msgstr "例如，如果我们有如下的 <literal>&lt;properties&gt;</literal> æ˜ å°„ï¼š"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You might have some legacy data association that refers to this unique key "
-"of the <literal>Person</literal> table, instead of to the primary key:"
-msgstr ""
-"然后，我们可能有一些遗留的数据关联，引用 <literal>Person</literal> 表的这个唯"
-"一键，而不是主键。"
+#, no-c-format
+msgid "You might have some legacy data association that refers to this unique key of the <literal>Person</literal> table, instead of to the primary key:"
+msgstr "然后，我们可能有一些遗留的数据关联，引用 <literal>Person</literal> 表的这个唯一键，而不是主键。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The use of this outside the context of mapping legacy data is not "
-"recommended."
-msgstr "æˆ‘ä»¬å¹¶ä¸æŽ¨èè¿™æ ·ä½¿ç”¨ï¼Œé™¤éžåœ¨æ˜ å°„é—ç•™æ•°æ®çš„æƒ…å†µä¸‹ã€‚"
+#, no-c-format
+msgid "The use of this outside the context of mapping legacy data is not recommended."
+msgstr "æˆ‘ä»¬å¹¶ä¸æŽ¨èè¿™æ ·ä½¿ç”¨ï¼Œé™¤éžåœ¨æ˜ å°„é—ç•™æ•°æ®çš„æƒ…å†µä¸‹ã€‚ "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Subclass"
-msgstr "子类（subclass）"
+msgstr "子类（subclass） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Polymorphic persistence requires the declaration of each subclass of the "
-"root persistent class. For the table-per-class-hierarchy mapping strategy, "
-"the <literal>&lt;subclass&gt;</literal> declaration is used. For example:"
-msgstr ""
-"æœ€åŽï¼Œå¤šæ€æŒä¹…åŒ–éœ€è¦ä¸ºçˆ¶ç±»çš„æ¯ä¸ªå­ç±»éƒ½è¿›è¡Œå®šä¹‰ã€‚å¯¹äºŽâ€œæ¯ä¸€æ£µç±»ç»§æ‰¿æ ‘å¯¹åº”ä¸€ä¸ª"
-"表”的策略来说，就需要使用 <literal>&lt;subclass&gt;</literal> 定义。"
+#, no-c-format
+msgid "Polymorphic persistence requires the declaration of each subclass of the root persistent class. For the table-per-class-hierarchy mapping strategy, the <literal>&lt;subclass&gt;</literal> declaration is used. For example:"
+msgstr "æœ€åŽï¼Œå¤šæ€æŒä¹…åŒ–éœ€è¦ä¸ºçˆ¶ç±»çš„æ¯ä¸ªå­ç±»éƒ½è¿›è¡Œå®šä¹‰ã€‚å¯¹äºŽâ€œæ¯ä¸€æ£µç±»ç»§æ‰¿æ ‘å¯¹åº”ä¸€ä¸ªè¡¨â€çš„ç­–ç•¥æ¥è¯´ï¼Œå°±éœ€è¦ä½¿ç”¨ <literal>&lt;subclass&gt;</literal> 定义。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>name</literal>: the fully qualified class name of the subclass."
-msgstr "<literal>name</literal>：子类的全限定名。"
+#, no-c-format
+msgid "<literal>name</literal>: the fully qualified class name of the subclass."
+msgstr "<literal>name</literal>：子类的全限定名。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>discriminator-value</literal> (optional - defaults to the class "
-"name): a value that distinguishes individual subclasses."
-msgstr ""
-"<literal>discriminator-valueï¼ˆè¾¨åˆ«æ ‡å¿—ï¼‰</literal>（可选 — 默认为类名）：一个"
-"用于区分每个独立的子类的值。"
+#, no-c-format
+msgid "<literal>discriminator-value</literal> (optional - defaults to the class name): a value that distinguishes individual subclasses."
+msgstr "<literal>discriminator-valueï¼ˆè¾¨åˆ«æ ‡å¿—ï¼‰</literal>（可选 — 默认为类名）：一个用于区分每个独立的子类的值。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>proxy</literal> (optional): specifies a class or interface used for "
-"lazy initializing proxies."
-msgstr ""
-"<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使"
-"用。"
+#, no-c-format
+msgid "<literal>proxy</literal> (optional): specifies a class or interface used for lazy initializing proxies."
+msgstr "<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使用。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional - defaults to <literal>true</literal>): "
-"setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
-msgstr ""
-"<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 "
-"<literal>lazy=\"false\"</literal> 禁止使用延迟装载。"
+#, no-c-format
+msgid "<literal>lazy</literal> (optional - defaults to <literal>true</literal>): setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 <literal>lazy=\"false\"</literal> 禁止使用延迟装载。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Each subclass declares its own persistent properties and subclasses. "
-"<literal>&lt;version&gt;</literal> and <literal>&lt;id&gt;</literal> "
-"properties are assumed to be inherited from the root class. Each subclass in "
-"a hierarchy must define a unique <literal>discriminator-value</literal>. If "
-"this is not specified, the fully qualified Java class name is used."
-msgstr ""
-"每个子类都应该定义它自己的持久化属性和子类。<literal>&lt;version&gt;</"
-"literal> å’Œ <literal>&lt;id&gt;</literal> å±žæ€§å¯ä»¥ä»Žæ ¹çˆ¶ç±»ç»§æ‰¿ä¸‹æ¥ã€‚åœ¨ä¸€æ£µç»§"
-"æ‰¿æ ‘ä¸Šçš„æ¯ä¸ªå­ç±»éƒ½å¿…é¡»å®šä¹‰ä¸€ä¸ªå”¯ä¸€çš„ <literal>discriminator-value</literal>。"
-"如果没有指定，就会使用 Java 类的全限定名。"
+#, no-c-format
+msgid "Each subclass declares its own persistent properties and subclasses. <literal>&lt;version&gt;</literal> and <literal>&lt;id&gt;</literal> properties are assumed to be inherited from the root class. Each subclass in a hierarchy must define a unique <literal>discriminator-value</literal>. If this is not specified, the fully qualified Java class name is used."
+msgstr "每个子类都应该定义它自己的持久化属性和子类。<literal>&lt;version&gt;</literal> å’Œ <literal>&lt;id&gt;</literal> å±žæ€§å¯ä»¥ä»Žæ ¹çˆ¶ç±»ç»§æ‰¿ä¸‹æ¥ã€‚åœ¨ä¸€æ£µç»§æ‰¿æ ‘ä¸Šçš„æ¯ä¸ªå­ç±»éƒ½å¿…é¡»å®šä¹‰ä¸€ä¸ªå”¯ä¸€çš„ <literal>discriminator-value</literal>。如果没有指定，就会使用 Java 类的全限定名。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For information about inheritance mappings see <xref linkend=\"inheritance"
-"\" />."
-msgstr "æ›´å¤šå…³äºŽç»§æ‰¿æ˜ å°„çš„ä¿¡æ¯ï¼Œå‚è€ƒ <xref linkend=\"Inheritance_Mapping\"/>。"
+#, no-c-format
+msgid "For information about inheritance mappings see <xref linkend=\"inheritance\" />."
+msgstr "æ›´å¤šå…³äºŽç»§æ‰¿æ˜ å°„çš„ä¿¡æ¯ï¼Œå‚è€ƒ <xref linkend=\"inheritance\" />。"
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Joined-subclass"
-msgstr "连接的子类（joined-subclass）"
+msgstr "连接的子类（joined-subclass） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Each subclass can also be mapped to its own table. This is called the table-"
-"per-subclass mapping strategy. An inherited state is retrieved by joining "
-"with the table of the superclass. To do this you use the <literal>&lt;joined-"
-"subclass&gt;</literal> element. For example:"
-msgstr ""
-"æ­¤å¤–ï¼Œæ¯ä¸ªå­ç±»å¯èƒ½è¢«æ˜ å°„åˆ°ä»–è‡ªå·±çš„è¡¨ä¸­ï¼ˆæ¯ä¸ªå­ç±»ä¸€ä¸ªè¡¨çš„ç­–ç•¥ï¼‰ã€‚è¢«ç»§æ‰¿çš„çŠ¶æ€"
-"通过和超类的表关联得到。我们使用 <literal>&lt;joined-subclass&gt;</literal> "
-"å…ƒç´ ã€‚"
+#, no-c-format
+msgid "Each subclass can also be mapped to its own table. This is called the table-per-subclass mapping strategy. An inherited state is retrieved by joining with the table of the superclass. To do this you use the <literal>&lt;joined-subclass&gt;</literal> element. For example:"
+msgstr "æ­¤å¤–ï¼Œæ¯ä¸ªå­ç±»å¯èƒ½è¢«æ˜ å°„åˆ°ä»–è‡ªå·±çš„è¡¨ä¸­ï¼ˆæ¯ä¸ªå­ç±»ä¸€ä¸ªè¡¨çš„ç­–ç•¥ï¼‰ã€‚è¢«ç»§æ‰¿çš„çŠ¶æ€é€šè¿‡å’Œè¶…ç±»çš„è¡¨å…³è”å¾—åˆ°ã€‚æˆ‘ä»¬ä½¿ç”¨ <literal>&lt;joined-subclass&gt;</literal> å…ƒç´ ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>table</literal>: the name of the subclass table."
-msgstr "<literal>table</literal>：子类的表名"
+msgstr "<literal>table</literal>：子类的表名。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>proxy</literal> (optional): specifies a class or interface to use "
-"for lazy initializing proxies."
-msgstr ""
-"<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使"
-"用。"
+#, no-c-format
+msgid "<literal>proxy</literal> (optional): specifies a class or interface to use for lazy initializing proxies."
+msgstr "<literal>proxy</literal>（可选）：指定一个类或者接口，在延迟装载时作为代理使用。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>lazy</literal> (optional, defaults to <literal>true</literal>): "
-"setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
-msgstr ""
-"<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 "
-"<literal>lazy=\"false\"</literal> 禁止使用延迟装载。"
+#, no-c-format
+msgid "<literal>lazy</literal> (optional, defaults to <literal>true</literal>): setting <literal>lazy=\"false\"</literal> disables the use of lazy fetching."
+msgstr "<literal>lazy</literal>（可选，默认是 <literal>true</literal>）：设置为 <literal>lazy=\"false\"</literal> 禁止使用延迟装载。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A discriminator column is not required for this mapping strategy. Each "
-"subclass must, however, declare a table column holding the object identifier "
-"using the <literal>&lt;key&gt;</literal> element. The mapping at the start "
-"of the chapter would then be re-written as:"
-msgstr ""
-"è¿™ç§æ˜ å°„ç­–ç•¥ä¸éœ€è¦æŒ‡å®šè¾¨åˆ«æ ‡å¿—ï¼ˆdiscriminator）字段。但是，每一个子类都必须使"
-"用 <literal>&lt;key&gt;</literal> å…ƒç´ æŒ‡å®šä¸€ä¸ªè¡¨å­—æ®µæ¥æŒæœ‰å¯¹è±¡çš„æ ‡è¯†ç¬¦ã€‚æœ¬ç« "
-"å¼€å§‹çš„æ˜ å°„å¯ä»¥è¢«ç”¨å¦‚ä¸‹æ–¹å¼é‡å†™ï¼š"
+#, no-c-format
+msgid "A discriminator column is not required for this mapping strategy. Each subclass must, however, declare a table column holding the object identifier using the <literal>&lt;key&gt;</literal> element. The mapping at the start of the chapter would then be re-written as:"
+msgstr "è¿™ç§æ˜ å°„ç­–ç•¥ä¸éœ€è¦æŒ‡å®šè¾¨åˆ«æ ‡å¿—ï¼ˆdiscriminator）字段。但是，每一个子类都必须使用 <literal>&lt;key&gt;</literal> å…ƒç´ æŒ‡å®šä¸€ä¸ªè¡¨å­—æ®µæ¥æŒæœ‰å¯¹è±¡çš„æ ‡è¯†ç¬¦ã€‚æœ¬ç« å¼€å§‹çš„æ˜ å°„å¯ä»¥è¢«ç”¨å¦‚ä¸‹æ–¹å¼é‡å†™ï¼š "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Union-subclass"
-msgstr "联合子类（union-subclass）"
+msgstr "联合子类（union-subclass） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A third option is to map only the concrete classes of an inheritance "
-"hierarchy to tables. This is called the table-per-concrete-class strategy. "
-"Each table defines all persistent states of the class, including the "
-"inherited state. In Hibernate, it is not necessary to explicitly map such "
-"inheritance hierarchies. You can map each class with a separate <literal>&lt;"
-"class&gt;</literal> declaration. However, if you wish use polymorphic "
-"associations (e.g. an association to the superclass of your hierarchy), you "
-"need to use the <literal>&lt;union-subclass&gt;</literal> mapping. For "
-"example:"
-msgstr ""
-"ç¬¬ä¸‰ç§é€‰æ‹©æ˜¯ä»…ä»…æ˜ å°„ç±»ç»§æ‰¿æ ‘ä¸­å…·ä½“ç±»éƒ¨åˆ†åˆ°è¡¨ä¸­ï¼ˆæ¯ä¸ªå…·ä½“ç±»ä¸€å¼ è¡¨çš„ç­–ç•¥ï¼‰ã€‚å…¶"
-"ä¸­ï¼Œæ¯å¼ è¡¨å®šä¹‰äº†ç±»çš„æ‰€æœ‰æŒä¹…åŒ–çŠ¶æ€ï¼ŒåŒ…æ‹¬ç»§æ‰¿çš„çŠ¶æ€ã€‚åœ¨ Hibernate 中，并不需要"
-"å®Œå…¨æ˜¾å¼åœ°æ˜ å°„è¿™æ ·çš„ç»§æ‰¿æ ‘ã€‚ä½ å¯ä»¥ç®€å•åœ°ä½¿ç”¨å•ç‹¬çš„ <literal>&lt;class&gt;</"
-"literal> å®šä¹‰æ˜ å°„æ¯ä¸ªç±»ã€‚ç„¶è€Œï¼Œå¦‚æžœä½ æƒ³ä½¿ç”¨å¤šæ€å…³è”ï¼ˆä¾‹å¦‚ï¼Œä¸€ä¸ªå¯¹ç±»ç»§æ‰¿æ ‘ä¸­è¶…"
-"ç±»çš„å…³è”ï¼‰ï¼Œä½ éœ€è¦ä½¿ç”¨ <literal>&lt;union-subclass&gt;</literal> æ˜ å°„ã€‚"
+#, no-c-format
+msgid "A third option is to map only the concrete classes of an inheritance hierarchy to tables. This is called the table-per-concrete-class strategy. Each table defines all persistent states of the class, including the inherited state. In Hibernate, it is not necessary to explicitly map such inheritance hierarchies. You can map each class with a separate <literal>&lt;class&gt;</literal> declaration. However, if you wish use polymorphic associations (e.g. an association to the superclass of your hierarchy), you need to use the <literal>&lt;union-subclass&gt;</literal> mapping. For example:"
+msgstr "ç¬¬ä¸‰ç§é€‰æ‹©æ˜¯ä»…ä»…æ˜ å°„ç±»ç»§æ‰¿æ ‘ä¸­å…·ä½“ç±»éƒ¨åˆ†åˆ°è¡¨ä¸­ï¼ˆæ¯ä¸ªå…·ä½“ç±»ä¸€å¼ è¡¨çš„ç­–ç•¥ï¼‰ã€‚å…¶ä¸­ï¼Œæ¯å¼ è¡¨å®šä¹‰äº†ç±»çš„æ‰€æœ‰æŒä¹…åŒ–çŠ¶æ€ï¼ŒåŒ…æ‹¬ç»§æ‰¿çš„çŠ¶æ€ã€‚åœ¨ Hibernate ä¸­ï¼Œå¹¶ä¸éœ€è¦å®Œå…¨æ˜¾å¼åœ°æ˜ å°„è¿™æ ·çš„ç»§æ‰¿æ ‘ã€‚ä½ å¯ä»¥ç®€å•åœ°ä½¿ç”¨å•ç‹¬çš„ <literal>&lt;class&gt;</literal> å®šä¹‰æ˜ å°„æ¯ä¸ªç±»ã€‚ç„¶è€Œï¼Œå¦‚æžœä½ æƒ³ä½¿ç”¨å¤šæ€å…³è”ï¼ˆä¾‹å¦‚ï¼Œä¸€ä¸ªå¯¹ç±»ç»§æ‰¿æ ‘ä¸­è¶…ç±»çš„å…³è”ï¼‰ï¼Œä½ éœ€è¦ä½¿ç”¨ <literal>&lt;union-subclass&gt;</literal> æ˜ å°„ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"No discriminator column or key column is required for this mapping strategy."
+msgid "No discriminator column or key column is required for this mapping strategy."
 msgstr "è¿™ç§æ˜ å°„ç­–ç•¥ä¸éœ€è¦æŒ‡å®šè¾¨åˆ«æ ‡å¿—ï¼ˆdiscriminator）字段。"
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Join"
-msgstr "连接（join）"
+msgstr "连接（join） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Using the <literal>&lt;join&gt;</literal> element, it is possible to map "
-"properties of one class to several tables that have a one-to-one "
-"relationship. For example:"
-msgstr ""
-"使用 <literal>&lt;join&gt;</literal> å…ƒç´ ï¼Œå‡è‹¥åœ¨è¡¨ä¹‹é—´å­˜åœ¨ä¸€å¯¹ä¸€å…³è”,可以将"
-"ä¸€ä¸ªç±»çš„å±žæ€§æ˜ å°„åˆ°å¤šå¼ è¡¨ä¸­ã€‚"
+#, no-c-format
+msgid "Using the <literal>&lt;join&gt;</literal> element, it is possible to map properties of one class to several tables that have a one-to-one relationship. For example:"
+msgstr "使用 <literal>&lt;join&gt;</literal> å…ƒç´ ï¼Œå‡è‹¥åœ¨è¡¨ä¹‹é—´å­˜åœ¨ä¸€å¯¹ä¸€å…³è”,å¯ä»¥å°†ä¸€ä¸ªç±»çš„å±žæ€§æ˜ å°„åˆ°å¤šå¼ è¡¨ä¸­ã€‚ä¾‹å¦‚ï¼š"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>table</literal>: the name of the joined table."
-msgstr "<literal>table</literal>：被连接表的名称。"
+msgstr "<literal>table</literal>：被连接表的名称。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>fetch</literal> (optional - defaults to <literal>join</literal>): "
-"if set to <literal>join</literal>, the default, Hibernate will use an inner "
-"join to retrieve a <literal>&lt;join&gt;</literal> defined by a class or its "
-"superclasses. It will use an outer join for a <literal>&lt;join&gt;</"
-"literal> defined by a subclass. If set to <literal>select</literal> then "
-"Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> "
-"defined on a subclass. This will be issued only if a row represents an "
-"instance of the subclass. Inner joins will still be used to retrieve a "
-"<literal>&lt;join&gt;</literal> defined by the class and its superclasses."
-msgstr ""
-"<literal>fetch</literal>（可选 — 默认是 <literal>join</literal>）：如果设置为"
-"默认值 <literal>join</literal>，Hibernate 将使用一个内连接来得到这个类或其超"
-"类定义的 <literal>&lt;join&gt;</literal>，而使用一个外连接来得到其子类定义的 "
-"<literal>&lt;join&gt;</literal>。如果设置为 <literal>select</literal>，则 "
-"Hibernate 将为子类定义的 <literal>&lt;join&gt;</literal> 使用顺序选择。这仅在"
-"一行数据表示一个子类的对象的时候才会发生。对这个类和其超类定义的 "
-"<literal>&lt;join&gt;</literal>，依然会使用内连接得到。"
+#, no-c-format
+msgid "<literal>fetch</literal> (optional - defaults to <literal>join</literal>): if set to <literal>join</literal>, the default, Hibernate will use an inner join to retrieve a <literal>&lt;join&gt;</literal> defined by a class or its superclasses. It will use an outer join for a <literal>&lt;join&gt;</literal> defined by a subclass. If set to <literal>select</literal> then Hibernate will use a sequential select for a <literal>&lt;join&gt;</literal> defined on a subclass. This will be issued only if a row represents an instance of the subclass. Inner joins will still be used to retrieve a <literal>&lt;join&gt;</literal> defined by the class and its superclasses."
+msgstr "<literal>fetch</literal>（可选 — 默认是 <literal>join</literal>）：如果设置为默认值 <literal>join</literal>，Hibernate 将使用一个内连接来得到这个类或其超类定义的 <literal>&lt;join&gt;</literal>，而使用一个外连接来得到其子类定义的 <literal>&lt;join&gt;</literal>。如果设置为 <literal>select</literal>，则 Hibernate 将为子类定义的 <literal>&lt;join&gt;</literal> 使用顺序选择。这仅在一行数据表示一个子类的对象的时候才会发生。对这个类和其超类定义的 <literal>&lt;join&gt;</literal>，依然会使用内连接得到。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>inverse</literal> (optional - defaults to <literal>false</"
-"literal>): if enabled, Hibernate will not insert or update the properties "
-"defined by this join."
-msgstr ""
-"<literal>inverse</literal>（可选 — 默认是 <literal>false</literal>）：如果打"
-"开，Hibernate 不会插入或者更新此连接定义的属性。"
+#, no-c-format
+msgid "<literal>inverse</literal> (optional - defaults to <literal>false</literal>): if enabled, Hibernate will not insert or update the properties defined by this join."
+msgstr "<literal>inverse</literal>（可选 — 默认是 <literal>false</literal>）：如果打开，Hibernate 不会插入或者更新此连接定义的属性。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optional</literal> (optional - defaults to <literal>false</"
-"literal>): if enabled, Hibernate will insert a row only if the properties "
-"defined by this join are non-null. It will always use an outer join to "
-"retrieve the properties."
-msgstr ""
-"<literal>optional</literal>（可选 — 默认是 <literal>false</literal>）：如果打"
-"开，Hibernate 只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连"
-"接来得到这些属性。"
+#, no-c-format
+msgid "<literal>optional</literal> (optional - defaults to <literal>false</literal>): if enabled, Hibernate will insert a row only if the properties defined by this join are non-null. It will always use an outer join to retrieve the properties."
+msgstr "<literal>optional</literal>（可选 — 默认是 <literal>false</literal>）：如果打开，Hibernate 只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连接来得到这些属性。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For example, address information for a person can be mapped to a separate "
-"table while preserving value type semantics for all properties:"
-msgstr ""
-"例如，一个人（person）的地址（addressï¼‰ä¿¡æ¯å¯ä»¥è¢«æ˜ å°„åˆ°å•ç‹¬çš„è¡¨ä¸­ï¼ˆå¹¶ä¿ç•™æ‰€æœ‰"
-"属性的值类型语义）："
+#, no-c-format
+msgid "For example, address information for a person can be mapped to a separate table while preserving value type semantics for all properties:"
+msgstr "例如，一个人（person）的地址（addressï¼‰ä¿¡æ¯å¯ä»¥è¢«æ˜ å°„åˆ°å•ç‹¬çš„è¡¨ä¸­ï¼ˆå¹¶ä¿ç•™æ‰€æœ‰å±žæ€§çš„å€¼ç±»åž‹è¯­ä¹‰ï¼‰ï¼š "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This feature is often only useful for legacy data models. We recommend fewer "
-"tables than classes and a fine-grained domain model. However, it is useful "
-"for switching between inheritance mapping strategies in a single hierarchy, "
-"as explained later."
-msgstr ""
-"此特性常常对遗留数据模型有用，我们推荐表个数比类个数少，以及细粒度的领域模"
-"åž‹ã€‚ç„¶è€Œï¼Œåœ¨å•ç‹¬çš„ç»§æ‰¿æ ‘ä¸Šåˆ‡æ¢ç»§æ‰¿æ˜ å°„ç­–ç•¥æ˜¯æœ‰ç”¨çš„ï¼ŒåŽé¢ä¼šè§£é‡Šè¿™ç‚¹ã€‚"
+#, no-c-format
+msgid "This feature is often only useful for legacy data models. We recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later."
+msgstr "æ­¤ç‰¹æ€§å¸¸å¸¸å¯¹é—ç•™æ•°æ®æ¨¡åž‹æœ‰ç”¨ï¼Œæˆ‘ä»¬æŽ¨èè¡¨ä¸ªæ•°æ¯”ç±»ä¸ªæ•°å°‘ï¼Œä»¥åŠç»†ç²’åº¦çš„é¢†åŸŸæ¨¡åž‹ã€‚ç„¶è€Œï¼Œåœ¨å•ç‹¬çš„ç»§æ‰¿æ ‘ä¸Šåˆ‡æ¢ç»§æ‰¿æ˜ å°„ç­–ç•¥æ˜¯æœ‰ç”¨çš„ï¼ŒåŽé¢ä¼šè§£é‡Šè¿™ç‚¹ã€‚ "
 
 #. Tag: title
 #, no-c-format
 msgid "Key"
-msgstr ""
+msgstr "Key"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>&lt;key&gt;</literal> element has featured a few times within "
-"this guide. It appears anywhere the parent mapping element defines a join to "
-"a new table that references the primary key of the original table. It also "
-"defines the foreign key in the joined table:"
-msgstr ""
-"我们目前已经见到过 <literal>&lt;key&gt;</literal> å…ƒç´ å¤šæ¬¡äº†ã€‚è¿™ä¸ªå…ƒç´ åœ¨çˆ¶æ˜ "
-"å°„å…ƒç´ å®šä¹‰äº†å¯¹æ–°è¡¨çš„è¿žæŽ¥ï¼Œå¹¶ä¸”åœ¨è¢«è¿žæŽ¥è¡¨ä¸­å®šä¹‰äº†ä¸€ä¸ªå¤–é”®å¼•ç”¨åŽŸè¡¨çš„ä¸»é”®çš„æƒ…å†µ"
-"下经常使用。"
+#, no-c-format
+msgid "The <literal>&lt;key&gt;</literal> element has featured a few times within this guide. It appears anywhere the parent mapping element defines a join to a new table that references the primary key of the original table. It also defines the foreign key in the joined table:"
+msgstr "我们目前已经见到过 <literal>&lt;key&gt;</literal> å…ƒç´ å¤šæ¬¡äº†ã€‚è¿™ä¸ªå…ƒç´ åœ¨çˆ¶æ˜ å°„å…ƒç´ å®šä¹‰äº†å¯¹æ–°è¡¨çš„è¿žæŽ¥ï¼Œå¹¶ä¸”åœ¨è¢«è¿žæŽ¥è¡¨ä¸­å®šä¹‰äº†ä¸€ä¸ªå¤–é”®å¼•ç”¨åŽŸè¡¨çš„ä¸»é”®çš„æƒ…å†µä¸‹ç»å¸¸ä½¿ç”¨ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>on-delete</literal> (optional - defaults to <literal>noaction</"
-"literal>): specifies whether the foreign key constraint has database-level "
-"cascade delete enabled."
-msgstr ""
-"<literal>on-delete</literal>（可选，默认是 <literal>noaction</literal>）：表"
-"æ˜Žå¤–é”®å…³è”æ˜¯å¦æ‰“å¼€æ•°æ®åº“çº§åˆ«çš„çº§è”åˆ é™¤ã€‚"
+#, no-c-format
+msgid "<literal>on-delete</literal> (optional - defaults to <literal>noaction</literal>): specifies whether the foreign key constraint has database-level cascade delete enabled."
+msgstr "<literal>on-delete</literal>（可选，默认是 <literal>noaction</literal>ï¼‰ï¼šè¡¨æ˜Žå¤–é”®å…³è”æ˜¯å¦æ‰“å¼€æ•°æ®åº“çº§åˆ«çš„çº§è”åˆ é™¤ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>property-ref</literal> (optional): specifies that the foreign key "
-"refers to columns that are not the primary key of the original table. It is "
-"provided for legacy data."
-msgstr ""
-"<literal>property-ref</literal>（可选）：表明外键引用的字段不是原表的主键（提"
-"供给遗留数据）。"
+#, no-c-format
+msgid "<literal>property-ref</literal> (optional): specifies that the foreign key refers to columns that are not the primary key of the original table. It is provided for legacy data."
+msgstr "<literal>property-ref</literal>（可选）：表明外键引用的字段不是原表的主键（提供给遗留数据）。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>not-null</literal> (optional): specifies that the foreign key "
-"columns are not nullable. This is implied whenever the foreign key is also "
-"part of the primary key."
-msgstr ""
-"<literal>not-null</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¡¨æ˜Žå¤–é”®çš„å­—æ®µä¸å¯ä¸ºç©ºï¼ˆè¿™æ„å‘³ç€æ— è®ºä½•æ—¶"
-"外键都是主键的一部分）。"
+#, no-c-format
+msgid "<literal>not-null</literal> (optional): specifies that the foreign key columns are not nullable. This is implied whenever the foreign key is also part of the primary key."
+msgstr "<literal>not-null</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¡¨æ˜Žå¤–é”®çš„å­—æ®µä¸å¯ä¸ºç©ºï¼ˆè¿™æ„å‘³ç€æ— è®ºä½•æ—¶å¤–é”®éƒ½æ˜¯ä¸»é”®çš„ä¸€éƒ¨åˆ†ï¼‰ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>update</literal> (optional): specifies that the foreign key should "
-"never be updated. This is implied whenever the foreign key is also part of "
-"the primary key."
-msgstr ""
-"<literal>update</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¡¨æ˜Žå¤–é”®å†³ä¸åº”è¯¥è¢«æ›´æ–°ï¼ˆè¿™æ„å‘³ç€æ— è®ºä½•æ—¶å¤–"
-"键都是主键的一部分）。"
+#, no-c-format
+msgid "<literal>update</literal> (optional): specifies that the foreign key should never be updated. This is implied whenever the foreign key is also part of the primary key."
+msgstr "<literal>update</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¡¨æ˜Žå¤–é”®å†³ä¸åº”è¯¥è¢«æ›´æ–°ï¼ˆè¿™æ„å‘³ç€æ— è®ºä½•æ—¶å¤–é”®éƒ½æ˜¯ä¸»é”®çš„ä¸€éƒ¨åˆ†ï¼‰ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>unique</literal> (optional): specifies that the foreign key should "
-"have a unique constraint. This is implied whenever the foreign key is also "
-"the primary key."
-msgstr ""
-"<literal>unique</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¡¨æ˜Žå¤–é”®åº”æœ‰å”¯ä¸€æ€§çº¦æŸï¼ˆè¿™æ„å‘³ç€æ— è®ºä½•æ—¶å¤–"
-"键都是主键的一部分）。"
+#, no-c-format
+msgid "<literal>unique</literal> (optional): specifies that the foreign key should have a unique constraint. This is implied whenever the foreign key is also the primary key."
+msgstr "<literal>unique</literal>ï¼ˆå¯é€‰ï¼‰ï¼šè¡¨æ˜Žå¤–é”®åº”æœ‰å”¯ä¸€æ€§çº¦æŸï¼ˆè¿™æ„å‘³ç€æ— è®ºä½•æ—¶å¤–é”®éƒ½æ˜¯ä¸»é”®çš„ä¸€éƒ¨åˆ†ï¼‰ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"For systems where delete performance is important, we recommend that all "
-"keys should be defined <literal>on-delete=\"cascade\"</literal>. Hibernate "
-"uses a database-level <literal>ON CASCADE DELETE</literal> constraint, "
-"instead of many individual <literal>DELETE</literal> statements. Be aware "
-"that this feature bypasses Hibernate's usual optimistic locking strategy for "
-"versioned data."
-msgstr ""
-"å¯¹é‚£äº›çœ‹é‡åˆ é™¤æ€§èƒ½çš„ç³»ç»Ÿï¼Œæˆ‘ä»¬æŽ¨èæ‰€æœ‰çš„é”®éƒ½åº”è¯¥å®šä¹‰ä¸º <literal>on-delete="
-"\"cascade\"</literal>ï¼Œè¿™æ · Hibernate 将使用数据库级的 <literal>ON CASCADE "
-"DELETE</literal> 约束，而不是多个 <literal>DELETE</literal> 语句。注意，这个"
-"特性会绕过 Hibernate 通常对版本数据（versioned data）采用的乐观锁策略。"
+#, no-c-format
+msgid "For systems where delete performance is important, we recommend that all keys should be defined <literal>on-delete=\"cascade\"</literal>. Hibernate uses a database-level <literal>ON CASCADE DELETE</literal> constraint, instead of many individual <literal>DELETE</literal> statements. Be aware that this feature bypasses Hibernate's usual optimistic locking strategy for versioned data."
+msgstr "å¯¹é‚£äº›çœ‹é‡åˆ é™¤æ€§èƒ½çš„ç³»ç»Ÿï¼Œæˆ‘ä»¬æŽ¨èæ‰€æœ‰çš„é”®éƒ½åº”è¯¥å®šä¹‰ä¸º <literal>on-delete=\"cascade\"</literal>ï¼Œè¿™æ · Hibernate 将使用数据库级的 <literal>ON CASCADE DELETE</literal> 约束，而不是多个 <literal>DELETE</literal> 语句。注意，这个特性会绕过 Hibernate 通常对版本数据（versioned data）采用的乐观锁策略。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>not-null</literal> and <literal>update</literal> attributes are "
-"useful when mapping a unidirectional one-to-many association. If you map a "
-"unidirectional one-to-many association to a non-nullable foreign key, you "
-"<emphasis>must</emphasis> declare the key column using <literal>&lt;key not-"
-"null=\"true\"&gt;</literal>."
-msgstr ""
-"<literal>not-null</literal> å’Œ <literal>update</literal> å±žæ€§åœ¨æ˜ å°„å•å‘ä¸€å¯¹å¤š"
-"å…³è”çš„æ—¶å€™æœ‰ç”¨ã€‚å¦‚æžœä½ æ˜ å°„ä¸€ä¸ªå•å‘ä¸€å¯¹å¤šå…³è”åˆ°éžç©ºçš„ï¼ˆnon-nullableï¼‰å¤–é”®ï¼Œä½ "
-"<emphasis>必须</emphasis> 用 <literal>&lt;key not-null=\"true\"&gt;</"
-"literal> 定义此键字段。"
+#, no-c-format
+msgid "The <literal>not-null</literal> and <literal>update</literal> attributes are useful when mapping a unidirectional one-to-many association. If you map a unidirectional one-to-many association to a non-nullable foreign key, you <emphasis>must</emphasis> declare the key column using <literal>&lt;key not-null=\"true\"&gt;</literal>."
+msgstr "<literal>not-null</literal> å’Œ <literal>update</literal> å±žæ€§åœ¨æ˜ å°„å•å‘ä¸€å¯¹å¤šå…³è”çš„æ—¶å€™æœ‰ç”¨ã€‚å¦‚æžœä½ æ˜ å°„ä¸€ä¸ªå•å‘ä¸€å¯¹å¤šå…³è”åˆ°éžç©ºçš„ï¼ˆnon-nullableï¼‰å¤–é”®ï¼Œä½ <emphasis>å¿…é¡»</emphasis> 用 <literal>&lt;key not-null=\"true\"&gt;</literal> 定义此键字段。 "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Column and formula elements"
-msgstr "å­—æ®µå’Œè§„åˆ™å…ƒç´ ï¼ˆcolumn and formula elements）"
+msgstr "å­—æ®µå’Œè§„åˆ™å…ƒç´ ï¼ˆcolumn and formula elements） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Mapping elements which accept a <literal>column</literal> attribute will "
-"alternatively accept a <literal>&lt;column&gt;</literal> subelement. "
-"Likewise, <literal>&lt;formula&gt;</literal> is an alternative to the "
-"<literal>formula</literal> attribute. For example:"
-msgstr ""
-"任何接受 <literal>column</literal> å±žæ€§çš„æ˜ å°„å…ƒç´ éƒ½å¯ä»¥é€‰æ‹©æŽ¥å— <literal>&lt;"
-"column&gt;</literal> å­å…ƒç´ ã€‚åŒæ ·çš„ï¼Œ<literal>formula</literal> å­å…ƒç´ ä¹Ÿå¯ä»¥"
-"替换 <literal>&lt;formula&gt;</literal> 属性。"
+#, no-c-format
+msgid "Mapping elements which accept a <literal>column</literal> attribute will alternatively accept a <literal>&lt;column&gt;</literal> subelement. Likewise, <literal>&lt;formula&gt;</literal> is an alternative to the <literal>formula</literal> attribute. For example:"
+msgstr "任何接受 <literal>column</literal> å±žæ€§çš„æ˜ å°„å…ƒç´ éƒ½å¯ä»¥é€‰æ‹©æŽ¥å— <literal>&lt;column&gt;</literal> å­å…ƒç´ ã€‚åŒæ ·çš„ï¼Œ<literal>formula</literal> å­å…ƒç´ ä¹Ÿå¯ä»¥æ›¿æ¢ <literal>&lt;formula&gt;</literal> 属性。例如："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>column</literal> and <literal>formula</literal> attributes can even "
-"be combined within the same property or association mapping to express, for "
-"example, exotic join conditions."
-msgstr ""
-"<literal>column</literal> 和 <literal>formula</literal> 属性甚至可以在同一个"
-"å±žæ€§æˆ–å…³è”æ˜ å°„ä¸­è¢«åˆå¹¶æ¥è¡¨è¾¾ï¼Œä¾‹å¦‚ï¼Œä¸€äº›å¥‡å¼‚çš„è¿žæŽ¥æ¡ä»¶ã€‚"
+#, no-c-format
+msgid "<literal>column</literal> and <literal>formula</literal> attributes can even be combined within the same property or association mapping to express, for example, exotic join conditions."
+msgstr "<literal>column</literal> å’Œ <literal>formula</literal> å±žæ€§ç”šè‡³å¯ä»¥åœ¨åŒä¸€ä¸ªå±žæ€§æˆ–å…³è”æ˜ å°„ä¸­è¢«åˆå¹¶æ¥è¡¨è¾¾ï¼Œä¾‹å¦‚ï¼Œä¸€äº›å¥‡å¼‚çš„è¿žæŽ¥æ¡ä»¶ã€‚ "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Import"
-msgstr "引用（import）"
+msgstr "引用（import） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If your application has two persistent classes with the same name, and you "
-"do not want to specify the fully qualified package name in Hibernate "
-"queries, classes can be \"imported\" explicitly, rather than relying upon "
-"<literal>auto-import=\"true\"</literal>. You can also import classes and "
-"interfaces that are not explicitly mapped:"
-msgstr ""
-"å‡è®¾ä½ çš„åº”ç”¨ç¨‹åºæœ‰ä¸¤ä¸ªåŒæ ·åå­—çš„æŒä¹…åŒ–ç±»ï¼Œä½†æ˜¯ä½ ä¸æƒ³åœ¨ Hibernate 查询中使用他"
-"们的全限定名。除了依赖 <literal>auto-import=\"true\"</literal> 以外，类也可以"
-"被显式地“importï¼ˆå¼•ç”¨ï¼‰â€ã€‚ä½ ç”šè‡³å¯ä»¥å¼•ç”¨æ²¡æœ‰è¢«æ˜Žç¡®æ˜ å°„çš„ç±»å’ŒæŽ¥å£ã€‚"
+#, no-c-format
+msgid "If your application has two persistent classes with the same name, and you do not want to specify the fully qualified package name in Hibernate queries, classes can be \"imported\" explicitly, rather than relying upon <literal>auto-import=\"true\"</literal>. You can also import classes and interfaces that are not explicitly mapped:"
+msgstr "å‡è®¾ä½ çš„åº”ç”¨ç¨‹åºæœ‰ä¸¤ä¸ªåŒæ ·åå­—çš„æŒä¹…åŒ–ç±»ï¼Œä½†æ˜¯ä½ ä¸æƒ³åœ¨ Hibernate 查询中使用他们的全限定名。除了依赖 <literal>auto-import=\"true\"</literal> 以外，类也可以被显式地“importï¼ˆå¼•ç”¨ï¼‰â€ã€‚ä½ ç”šè‡³å¯ä»¥å¼•ç”¨æ²¡æœ‰è¢«æ˜Žç¡®æ˜ å°„çš„ç±»å’ŒæŽ¥å£ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>class</literal>: the fully qualified class name of any Java class."
-msgstr "<literal>class</literal>：任何 Java 类的全限定名。"
+#, no-c-format
+msgid "<literal>class</literal>: the fully qualified class name of any Java class."
+msgstr "<literal>class</literal>：任何 Java 类的全限定名。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>rename</literal> (optional - defaults to the unqualified class "
-"name): a name that can be used in the query language."
-msgstr ""
-"<literal>rename</literal>（可选 — 默认为类的全限定名）：在查询语句中可以使用"
-"的名字。"
+#, no-c-format
+msgid "<literal>rename</literal> (optional - defaults to the unqualified class name): a name that can be used in the query language."
+msgstr "<literal>rename</literal>（可选 — 默认为类的全限定名）：在查询语句中可以使用的名字。 "
 
 #. Tag: title
 #, no-c-format
 msgid "Any"
-msgstr ""
+msgstr "Any"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"There is one more type of property mapping. The <literal>&lt;any&gt;</"
-"literal> mapping element defines a polymorphic association to classes from "
-"multiple tables. This type of mapping requires more than one column. The "
-"first column contains the type of the associated entity. The remaining "
-"columns contain the identifier. It is impossible to specify a foreign key "
-"constraint for this kind of association. This is not the usual way of "
-"mapping polymorphic associations and you should use this only in special "
-"cases. For example, for audit logs, user session data, etc."
-msgstr ""
-"è¿™æ˜¯å±žæ€§æ˜ å°„çš„åˆä¸€ç§ç±»åž‹ã€‚<literal>&lt;any&gt;</literal> æ˜ å°„å…ƒç´ å®šä¹‰äº†ä¸€ç§ä»Ž"
-"å¤šä¸ªè¡¨åˆ°ç±»çš„å¤šæ€å…³è”ã€‚è¿™ç§ç±»åž‹çš„æ˜ å°„å¸¸å¸¸éœ€è¦å¤šäºŽä¸€ä¸ªå­—æ®µã€‚ç¬¬ä¸€ä¸ªå­—æ®µæŒæœ‰è¢«å…³"
-"è”å®žä½“çš„ç±»åž‹ï¼Œå…¶ä»–çš„å­—æ®µæŒæœ‰æ ‡è¯†ç¬¦ã€‚å¯¹è¿™ç§ç±»åž‹çš„å…³è”æ¥è¯´ï¼Œä¸å¯èƒ½æŒ‡å®šä¸€ä¸ªå¤–é”®"
-"çº¦æŸï¼Œæ‰€ä»¥è¿™å½“ç„¶ä¸æ˜¯æ˜ å°„ï¼ˆå¤šæ€ï¼‰å…³è”çš„é€šå¸¸çš„æ–¹å¼ã€‚ä½ åªåº”è¯¥åœ¨éžå¸¸ç‰¹æ®Šçš„æƒ…å†µä¸‹"
-"使用它(比如，审计 log，用户会话数据等等)。"
+#, no-c-format
+msgid "There is one more type of property mapping. The <literal>&lt;any&gt;</literal> mapping element defines a polymorphic association to classes from multiple tables. This type of mapping requires more than one column. The first column contains the type of the associated entity. The remaining columns contain the identifier. It is impossible to specify a foreign key constraint for this kind of association. This is not the usual way of mapping polymorphic associations and you should use this only in special cases. For example, for audit logs, user session data, etc."
+msgstr "è¿™æ˜¯å±žæ€§æ˜ å°„çš„åˆä¸€ç§ç±»åž‹ã€‚<literal>&lt;any&gt;</literal> æ˜ å°„å…ƒç´ å®šä¹‰äº†ä¸€ç§ä»Žå¤šä¸ªè¡¨åˆ°ç±»çš„å¤šæ€å…³è”ã€‚è¿™ç§ç±»åž‹çš„æ˜ å°„å¸¸å¸¸éœ€è¦å¤šäºŽä¸€ä¸ªå­—æ®µã€‚ç¬¬ä¸€ä¸ªå­—æ®µæŒæœ‰è¢«å…³è”å®žä½“çš„ç±»åž‹ï¼Œå…¶ä»–çš„å­—æ®µæŒæœ‰æ ‡è¯†ç¬¦ã€‚å¯¹è¿™ç§ç±»åž‹çš„å…³è”æ¥è¯´ï¼Œä¸å¯èƒ½æŒ‡å®šä¸€ä¸ªå¤–é”®çº¦æŸï¼Œæ‰€ä»¥è¿™å½“ç„¶ä¸æ˜¯æ˜ å°„ï¼ˆå¤šæ€ï¼‰å…³è”çš„é€šå¸¸çš„æ–¹å¼ã€‚ä½ åªåº”è¯¥åœ¨éžå¸¸ç‰¹æ®Šçš„æƒ…å†µä¸‹ä½¿ç”¨å®ƒ(比如，审计 log，用户会话数据等等)。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>meta-type</literal> attribute allows the application to specify "
-"a custom type that maps database column values to persistent classes that "
-"have identifier properties of the type specified by <literal>id-type</"
-"literal>. You must specify the mapping from values of the meta-type to class "
-"names."
-msgstr ""
-"<literal>meta-type</literal> å±žæ€§ä½¿å¾—åº”ç”¨ç¨‹åºèƒ½æŒ‡å®šä¸€ä¸ªå°†æ•°æ®åº“å­—æ®µçš„å€¼æ˜ å°„åˆ°"
-"持久化类的自定义类型。这个持久化类包含有用 <literal>id-type</literal> 指定的"
-"æ ‡è¯†ç¬¦å±žæ€§ã€‚ä½ å¿…é¡»æŒ‡å®šä»Ž meta-type çš„å€¼åˆ°ç±»åçš„æ˜ å°„ã€‚"
+#, no-c-format
+msgid "The <literal>meta-type</literal> attribute allows the application to specify a custom type that maps database column values to persistent classes that have identifier properties of the type specified by <literal>id-type</literal>. You must specify the mapping from values of the meta-type to class names."
+msgstr "<literal>meta-type</literal> å±žæ€§ä½¿å¾—åº”ç”¨ç¨‹åºèƒ½æŒ‡å®šä¸€ä¸ªå°†æ•°æ®åº“å­—æ®µçš„å€¼æ˜ å°„åˆ°æŒä¹…åŒ–ç±»çš„è‡ªå®šä¹‰ç±»åž‹ã€‚è¿™ä¸ªæŒä¹…åŒ–ç±»åŒ…å«æœ‰ç”¨ <literal>id-type</literal> æŒ‡å®šçš„æ ‡è¯†ç¬¦å±žæ€§ã€‚ä½ å¿…é¡»æŒ‡å®šä»Ž meta-type çš„å€¼åˆ°ç±»åçš„æ˜ å°„ã€‚ "
 
 #. Tag: para
 #, no-c-format
@@ -3098,39 +1551,24 @@
 msgstr "<literal>id-type</literal>ï¼šæ ‡è¯†ç¬¦ç±»åž‹"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>meta-type</literal> (optional - defaults to <literal>string</"
-"literal>): any type that is allowed for a discriminator mapping."
-msgstr ""
-"<literal>meta-type</literal>（可选 -默认是 <literal>string</literal>）：允许"
-"è¾¨åˆ«æ ‡å¿—(discriminator)æ˜ å°„çš„ä»»ä½•ç±»åž‹ã€‚"
+#, no-c-format
+msgid "<literal>meta-type</literal> (optional - defaults to <literal>string</literal>): any type that is allowed for a discriminator mapping."
+msgstr "<literal>meta-type</literal>（可选 -默认是 <literal>string</literal>ï¼‰ï¼šå…è®¸è¾¨åˆ«æ ‡å¿—(discriminator)æ˜ å°„çš„ä»»ä½•ç±»åž‹ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>cascade</literal> (optional- defaults to <literal>none</literal>): "
-"the cascade style."
-msgstr ""
-"<literal>cascade</literal>（可选 — 默认是<literal>none</literal>）：级联的类"
-"型。"
+msgid "<literal>cascade</literal> (optional- defaults to <literal>none</literal>): the cascade style."
+msgstr "<literal>cascade</literal>（可选 — 默认是<literal>none</literal>）：级联的类型。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>optimistic-lock</literal> (optional - defaults to <literal>true</"
-"literal>): specifies that updates to this property either do or do not "
-"require acquisition of the optimistic lock. It defines whether a version "
-"increment should occur if this property is dirty."
-msgstr ""
-"<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>）："
-"è¡¨æ˜Žæ›´æ–°æ­¤ç»„ä»¶æ˜¯å¦éœ€è¦èŽ·å–ä¹è§‚é”ã€‚æ¢å¥è¯è¯´ï¼Œå½“è¿™ä¸ªå±žæ€§å˜è„æ—¶ï¼Œæ˜¯å¦å¢žåŠ ç‰ˆæœ¬å·"
-"（Version）"
+#, no-c-format
+msgid "<literal>optimistic-lock</literal> (optional - defaults to <literal>true</literal>): specifies that updates to this property either do or do not require acquisition of the optimistic lock. It defines whether a version increment should occur if this property is dirty."
+msgstr "<literal>optimistic-lock</literal>（可选 — 默认是 <literal>true</literal>ï¼‰ï¼šè¡¨æ˜Žæ›´æ–°æ­¤ç»„ä»¶æ˜¯å¦éœ€è¦èŽ·å–ä¹è§‚é”ã€‚æ¢å¥è¯è¯´ï¼Œå½“è¿™ä¸ªå±žæ€§å˜è„æ—¶ï¼Œæ˜¯å¦å¢žåŠ ç‰ˆæœ¬å·ï¼ˆVersion）。"
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Hibernate types"
-msgstr "Hibernate 的类型"
+msgstr "Hibernate 的类型 "
 
 #. Tag: title
 #, no-c-format
@@ -3139,108 +1577,38 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In relation to the persistence service, Java language-level objects are "
-"classified into two groups:"
+msgid "In relation to the persistence service, Java language-level objects are classified into two groups:"
 msgstr "和持久化服务相比，Java 级别的对象分为两个组别："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"An <emphasis>entity</emphasis> exists independently of any other objects "
-"holding references to the entity. Contrast this with the usual Java model, "
-"where an unreferenced object is garbage collected. Entities must be "
-"explicitly saved and deleted. Saves and deletions, however, can be "
-"<emphasis>cascaded</emphasis> from a parent entity to its children. This is "
-"different from the ODMG model of object persistence by reachability and "
-"corresponds more closely to how application objects are usually used in "
-"large systems. Entities support circular and shared references. They can "
-"also be versioned."
-msgstr ""
-"<emphasis>实体entity</emphasis> 独立于任何持有实体引用的对象。与通常的 Java "
-"æ¨¡åž‹ç›¸æ¯”ï¼Œä¸å†è¢«å¼•ç”¨çš„å¯¹è±¡ä¼šè¢«å½“ä½œåžƒåœ¾æ”¶é›†æŽ‰ã€‚å®žä½“å¿…é¡»è¢«æ˜¾å¼çš„ä¿å­˜å’Œåˆ é™¤ï¼ˆé™¤"
-"éžä¿å­˜å’Œåˆ é™¤æ˜¯ä»Žçˆ¶å®žä½“å‘å­å®žä½“å¼•å‘çš„<emphasis>级联</emphasis>）。这和 ODMG 模"
-"型中关于对象通过可触及保持持久性有一些不同 — æ¯”è¾ƒèµ·æ¥æ›´åŠ æŽ¥è¿‘åº”ç”¨ç¨‹åºå¯¹è±¡é€šå¸¸"
-"åœ¨ä¸€ä¸ªå¤§ç³»ç»Ÿä¸­çš„ä½¿ç”¨æ–¹æ³•ã€‚å®žä½“æ”¯æŒå¾ªçŽ¯å¼•ç”¨å’Œäº¤å‰å¼•ç”¨ï¼Œå®ƒä»¬ä¹Ÿå¯ä»¥åŠ ä¸Šç‰ˆæœ¬ä¿¡"
-"息。"
+#, no-c-format
+msgid "An <emphasis>entity</emphasis> exists independently of any other objects holding references to the entity. Contrast this with the usual Java model, where an unreferenced object is garbage collected. Entities must be explicitly saved and deleted. Saves and deletions, however, can be <emphasis>cascaded</emphasis> from a parent entity to its children. This is different from the ODMG model of object persistence by reachability and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They can also be versioned."
+msgstr "<emphasis>实体entity</emphasis> 独立于任何持有实体引用的对象。与通常的 Java æ¨¡åž‹ç›¸æ¯”ï¼Œä¸å†è¢«å¼•ç”¨çš„å¯¹è±¡ä¼šè¢«å½“ä½œåžƒåœ¾æ”¶é›†æŽ‰ã€‚å®žä½“å¿…é¡»è¢«æ˜¾å¼çš„ä¿å­˜å’Œåˆ é™¤ï¼ˆé™¤éžä¿å­˜å’Œåˆ é™¤æ˜¯ä»Žçˆ¶å®žä½“å‘å­å®žä½“å¼•å‘çš„<emphasis>级联</emphasis>）。这和 ODMG 模型中关于对象通过可触及保持持久性有一些不同 — æ¯”è¾ƒèµ·æ¥æ›´åŠ æŽ¥è¿‘åº”ç”¨ç¨‹åºå¯¹è±¡é€šå¸¸åœ¨ä¸€ä¸ªå¤§ç³»ç»Ÿä¸­çš„ä½¿ç”¨æ–¹æ³•ã€‚å®žä½“æ”¯æŒå¾ªçŽ¯å¼•ç”¨å’Œäº¤å‰å¼•ç”¨ï¼Œå®ƒä»¬ä¹Ÿå¯ä»¥åŠ ä¸Šç‰ˆæœ¬ä¿¡æ¯ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"An entity's persistent state consists of references to other entities and "
-"instances of <emphasis>value</emphasis> types. Values are primitives: "
-"collections (not what is inside a collection), components and certain "
-"immutable objects. Unlike entities, values in particular collections and "
-"components, <emphasis>are</emphasis> persisted and deleted by reachability. "
-"Since value objects and primitives are persisted and deleted along with "
-"their containing entity, they cannot be independently versioned. Values have "
-"no independent identity, so they cannot be shared by two entities or "
-"collections."
-msgstr ""
-"一个实体的持久状态包含指向其他实体和<emphasis>值</emphasis>类型实例的引用。值"
-"可以是原始类型，集合（不是集合中的对象），组件或者特定的不可变对象。与实体不"
-"åŒï¼Œå€¼ï¼ˆç‰¹åˆ«æ˜¯é›†åˆå’Œç»„ä»¶ï¼‰æ˜¯é€šè¿‡å¯è§¦åŠæ€§æ¥è¿›è¡ŒæŒä¹…åŒ–å’Œåˆ é™¤çš„ã€‚å› ä¸ºå€¼å¯¹è±¡ï¼ˆå’Œ"
-"åŽŸå§‹ç±»åž‹æ•°æ®ï¼‰æ˜¯éšç€åŒ…å«ä»–ä»¬çš„å®žä½“è€Œè¢«æŒä¹…åŒ–å’Œåˆ é™¤çš„ï¼Œä»–ä»¬ä¸èƒ½è¢«ç‹¬ç«‹çš„åŠ ä¸Šç‰ˆ"
-"æœ¬ä¿¡æ¯ã€‚å€¼æ²¡æœ‰ç‹¬ç«‹çš„æ ‡è¯†ï¼Œæ‰€ä»¥ä»–ä»¬ä¸èƒ½è¢«ä¸¤ä¸ªå®žä½“æˆ–è€…é›†åˆå…±äº«ã€‚"
+#, no-c-format
+msgid "An entity's persistent state consists of references to other entities and instances of <emphasis>value</emphasis> types. Values are primitives: collections (not what is inside a collection), components and certain immutable objects. Unlike entities, values in particular collections and components, <emphasis>are</emphasis> persisted and deleted by reachability. Since value objects and primitives are persisted and deleted along with their containing entity, they cannot be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections."
+msgstr "一个实体的持久状态包含指向其他实体和<emphasis>值</emphasis>ç±»åž‹å®žä¾‹çš„å¼•ç”¨ã€‚å€¼å¯ä»¥æ˜¯åŽŸå§‹ç±»åž‹ï¼Œé›†åˆï¼ˆä¸æ˜¯é›†åˆä¸­çš„å¯¹è±¡ï¼‰ï¼Œç»„ä»¶æˆ–è€…ç‰¹å®šçš„ä¸å¯å˜å¯¹è±¡ã€‚ä¸Žå®žä½“ä¸åŒï¼Œå€¼ï¼ˆç‰¹åˆ«æ˜¯é›†åˆå’Œç»„ä»¶ï¼‰æ˜¯é€šè¿‡å¯è§¦åŠæ€§æ¥è¿›è¡ŒæŒä¹…åŒ–å’Œåˆ é™¤çš„ã€‚å› ä¸ºå€¼å¯¹è±¡ï¼ˆå’ŒåŽŸå§‹ç±»åž‹æ•°æ®ï¼‰æ˜¯éšç€åŒ…å«ä»–ä»¬çš„å®žä½“è€Œè¢«æŒä¹…åŒ–å’Œåˆ é™¤çš„ï¼Œä»–ä»¬ä¸èƒ½è¢«ç‹¬ç«‹çš„åŠ ä¸Šç‰ˆæœ¬ä¿¡æ¯ã€‚å€¼æ²¡æœ‰ç‹¬ç«‹çš„æ ‡è¯†ï¼Œæ‰€ä»¥ä»–ä»¬ä¸èƒ½è¢«ä¸¤ä¸ªå®žä½“æˆ–è€…é›†åˆå…±äº«ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Until now, we have been using the term \"persistent class\" to refer to "
-"entities. We will continue to do that. Not all user-defined classes with a "
-"persistent state, however, are entities. A <emphasis>component</emphasis> is "
-"a user-defined class with value semantics. A Java property of type "
-"<literal>java.lang.String</literal> also has value semantics. Given this "
-"definition, all types (classes) provided by the JDK have value type "
-"semantics in Java, while user-defined types can be mapped with entity or "
-"value type semantics. This decision is up to the application developer. An "
-"entity class in a domain model will normally have shared references to a "
-"single instance of that class, while composition or aggregation usually "
-"translates to a value type."
-msgstr ""
-"直到现在，我们都一直使用术语“持久类”（persistent class）来代表实体。我们仍然"
-"ä¼šè¿™ä¹ˆåšã€‚ç„¶è€Œä¸¥æ ¼è¯´æ¥ï¼Œä¸æ˜¯æ‰€æœ‰çš„ç”¨æˆ·è‡ªå®šä¹‰çš„ï¼Œå¸¦æœ‰æŒä¹…åŒ–çŠ¶æ€çš„ç±»éƒ½æ˜¯å®žä½“ã€‚"
-"<emphasis>组件</emphasis>就是用户自定义类，却是值语义的。<literal>java.lang."
-"String</literal> 类型的 java 属性也是值语义的。给了这个定义以后，我们可以说所"
-"有 JDK æä¾›çš„ç±»åž‹ï¼ˆç±»ï¼‰éƒ½æ˜¯å€¼ç±»åž‹çš„è¯­ä¹‰ï¼Œè€Œç”¨äºŽè‡ªå®šä¹‰ç±»åž‹å¯èƒ½è¢«æ˜ å°„ä¸ºå®žä½“ç±»åž‹"
-"或值类型语义。采用哪种类型的语义取决于开发人员。在领域模型中，寻找实体类的一"
-"个好线索是共享引用指向这个类的单一实例，而组合或聚合通常被转化为值类型。"
+#, no-c-format
+msgid "Until now, we have been using the term \"persistent class\" to refer to entities. We will continue to do that. Not all user-defined classes with a persistent state, however, are entities. A <emphasis>component</emphasis> is a user-defined class with value semantics. A Java property of type <literal>java.lang.String</literal> also has value semantics. Given this definition, all types (classes) provided by the JDK have value type semantics in Java, while user-defined types can be mapped with entity or value type semantics. This decision is up to the application developer. An entity class in a domain model will normally have shared references to a single instance of that class, while composition or aggregation usually translates to a value type."
+msgstr "直到现在，我们都一直使用术语“持久类”（persistent classï¼‰æ¥ä»£è¡¨å®žä½“ã€‚æˆ‘ä»¬ä»ç„¶ä¼šè¿™ä¹ˆåšã€‚ç„¶è€Œä¸¥æ ¼è¯´æ¥ï¼Œä¸æ˜¯æ‰€æœ‰çš„ç”¨æˆ·è‡ªå®šä¹‰çš„ï¼Œå¸¦æœ‰æŒä¹…åŒ–çŠ¶æ€çš„ç±»éƒ½æ˜¯å®žä½“ã€‚<emphasis>组件</emphasis>就是用户自定义类，却是值语义的。<literal>java.lang.String</literal> 类型的 java 属性也是值语义的。给了这个定义以后，我们可以说所有 JDK æä¾›çš„ç±»åž‹ï¼ˆç±»ï¼‰éƒ½æ˜¯å€¼ç±»åž‹çš„è¯­ä¹‰ï¼Œè€Œç”¨äºŽè‡ªå®šä¹‰ç±»åž‹å¯èƒ½è¢«æ˜ å°„ä¸ºå®žä½“ç±»åž‹æˆ–å€¼ç±»åž‹è¯­ä¹‰ã€‚é‡‡ç”¨å“ªç§ç±»åž‹çš„è¯­ä¹‰å–å†³äºŽå¼€å‘äººå‘˜ã€‚åœ¨é¢†åŸŸæ¨¡åž‹ä¸­ï¼Œå¯»æ‰¾å®žä½“ç±»çš„ä¸€ä¸ªå¥½çº¿ç´¢æ˜¯å…±äº«å¼•ç”¨æŒ‡å‘è¿™ä¸ªç±»çš„å•ä¸€å®žä¾‹ï¼Œè€Œç»„åˆæˆ–èšåˆé€šå¸¸è¢«è½¬åŒ–ä¸ºå€¼ç±»åž‹ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "We will revisit both concepts throughout this reference guide."
-msgstr "我们会在本文档中重复碰到这两个概念。"
+msgstr "我们会在本文档中重复碰到这两个概念。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The challenge is to map the Java type system, and the developers' definition "
-"of entities and value types, to the SQL/database type system. The bridge "
-"between both systems is provided by Hibernate. For entities, <literal>&lt;"
-"class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on are used. "
-"For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;"
-"component&gt;</literal>etc., that usually have a <literal>type</literal> "
-"attribute. The value of this attribute is the name of a Hibernate "
-"<emphasis>mapping type</emphasis>. Hibernate provides a range of mappings "
-"for standard JDK value types out of the box. You can write your own mapping "
-"types and implement your own custom conversion strategies."
-msgstr ""
-"挑战在于将 java 类型系统(和开发者定义的实体和值类型)æ˜ å°„åˆ° SQL/数据库类型系"
-"统。Hibernate 提供了连接两个系统之间的桥梁：对于实体类型，我们使用 "
-"<literal>&lt;class&gt;</literal>，<literal>&lt;subclass&gt;</literal> 等等。"
-"对于值类型，我们使用 <literal>&lt;property&gt;</literal>，<literal>&lt;"
-"component&gt;</literal> 及其他，通常跟随着 <literal>type</literal> 属性。这个"
-"属性的值是Hibernate çš„<emphasis>æ˜ å°„ç±»åž‹</emphasis>的名字。Hibernate 提供了许"
-"å¤šçŽ°æˆçš„æ˜ å°„ï¼ˆæ ‡å‡†çš„ JDK å€¼ç±»åž‹ï¼‰ã€‚ä½ ä¹Ÿå¯ä»¥ç¼–å†™è‡ªå·±çš„æ˜ å°„ç±»åž‹å¹¶å®žçŽ°è‡ªå®šä¹‰çš„å˜"
-"换策略，随后我们会看到这点。"
+#, no-c-format
+msgid "The challenge is to map the Java type system, and the developers' definition of entities and value types, to the SQL/database type system. The bridge between both systems is provided by Hibernate. For entities, <literal>&lt;class&gt;</literal>, <literal>&lt;subclass&gt;</literal> and so on are used. For value types we use <literal>&lt;property&gt;</literal>, <literal>&lt;component&gt;</literal>etc., that usually have a <literal>type</literal> attribute. The value of this attribute is the name of a Hibernate <emphasis>mapping type</emphasis>. Hibernate provides a range of mappings for standard JDK value types out of the box. You can write your own mapping types and implement your own custom conversion strategies."
+msgstr "挑战在于将 java 类型系统(和开发者定义的实体和值类型)æ˜ å°„åˆ° SQL/数据库类型系统。Hibernate 提供了连接两个系统之间的桥梁：对于实体类型，我们使用 <literal>&lt;class&gt;</literal>，<literal>&lt;subclass&gt;</literal> 等等。对于值类型，我们使用 <literal>&lt;property&gt;</literal>，<literal>&lt;component&gt;</literal> 及其他，通常跟随着 <literal>type</literal> 属性。这个属性的值是Hibernate çš„<emphasis>æ˜ å°„ç±»åž‹</emphasis>的名字。Hibernate æä¾›äº†è®¸å¤šçŽ°æˆçš„æ˜ å°„ï¼ˆæ ‡å‡†çš„ JDK å€¼ç±»åž‹ï¼‰ã€‚ä½ ä¹Ÿå¯ä»¥ç¼–å†™è‡ªå·±çš„æ˜ å°„ç±»åž‹å¹¶å®žçŽ°è‡ªå®šä¹‰çš„å˜æ¢ç­–ç•¥ï¼ŒéšåŽæˆ‘ä»¬ä¼šçœ‹åˆ°è¿™ç‚¹ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"With the exception of collections, all built-in Hibernate types support null "
-"semantics."
-msgstr ""
-"所有的 Hibernate 内建类型，除了 collections 以外，都支持空（null）语义。"
+#, no-c-format
+msgid "With the exception of collections, all built-in Hibernate types support null semantics."
+msgstr "所有的 Hibernate 内建类型，除了 collections 以外，都支持空（null）语义。 "
 
 #. Tag: title
 #, no-c-format
@@ -3248,138 +1616,84 @@
 msgstr "基本值类型"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The built-in <emphasis>basic mapping types</emphasis> can be roughly "
-"categorized into the following:"
-msgstr ""
-"内置的 <emphasis>basic mapping types</emphasis> 可以大致地分类至categorized "
-"into"
+#, no-c-format
+msgid "The built-in <emphasis>basic mapping types</emphasis> can be roughly categorized into the following:"
+msgstr "内置的 <emphasis>basic mapping types</emphasis> 可以大致地分类为："
 
 #. Tag: term
-#, fuzzy, no-c-format
-msgid ""
-"<literal>integer, long, short, float, double, character, byte, boolean, "
-"yes_no, true_false</literal>"
-msgstr ""
-"integer, long, short, float, double, character, byte, boolean, yes_no, "
-"true_false"
+#, no-c-format
+msgid "<literal>integer, long, short, float, double, character, byte, boolean, yes_no, true_false</literal>"
+msgstr "<literal>integer, long, short, float, double, character, byte, boolean, yes_no, true_false</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Type mappings from Java primitives or wrapper classes to appropriate (vendor-"
-"specific) SQL column types. <literal>boolean, yes_no</literal> and "
-"<literal>true_false</literal> are all alternative encodings for a Java "
-"<literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
-msgstr ""
-"这些类型都对应 Java 的原始类型或者其封装类，来符合（特定厂商的）SQL 字段类"
-"型。<literal>boolean, yes_no</literal> 和 <literal>true_false</literal> 都是 "
-"Java 中 <literal>boolean</literal> 或者 <literal>java.lang.Boolean</literal> "
-"的另外说法。"
+msgid "Type mappings from Java primitives or wrapper classes to appropriate (vendor-specific) SQL column types. <literal>boolean, yes_no</literal> and <literal>true_false</literal> are all alternative encodings for a Java <literal>boolean</literal> or <literal>java.lang.Boolean</literal>."
+msgstr "这些类型都对应 Java 的原始类型或者其封装类，来符合（特定厂商的）SQL 字段类型。<literal>boolean, yes_no</literal> 和 <literal>true_false</literal> 都是 Java 中 <literal>boolean</literal> 或者 <literal>java.lang.Boolean</literal> 的另外说法。"
 
 #. Tag: term
 #, no-c-format
 msgid "<literal>string</literal>"
-msgstr ""
+msgstr "<literal>string</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</"
-"literal> (or Oracle <literal>VARCHAR2</literal>)."
-msgstr ""
-"从 <literal>java.lang.String</literal> 到 <literal>VARCHAR</literal>（或者 "
-"Oracle çš„ <literal>VARCHAR2</literal>ï¼‰çš„æ˜ å°„ã€‚"
+msgid "A type mapping from <literal>java.lang.String</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>)."
+msgstr "从 <literal>java.lang.String</literal> 到 <literal>VARCHAR</literal>（或者 Oracle çš„ <literal>VARCHAR2</literal>ï¼‰çš„æ˜ å°„ã€‚"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>date, time, timestamp</literal>"
-msgstr "date, time, timestamp"
+msgstr "<literal>date, time, timestamp</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Type mappings from <literal>java.util.Date</literal> and its subclasses to "
-"SQL types <literal>DATE</literal>, <literal>TIME</literal> and "
-"<literal>TIMESTAMP</literal> (or equivalent)."
-msgstr ""
-"从 <literal>java.util.Date</literal> 和其子类到 SQL 类型 <literal>DATE</"
-"literal>，<literal>TIME</literal> 和 <literal>TIMESTAMP</literal>（或等价类"
-"åž‹ï¼‰çš„æ˜ å°„ã€‚"
+msgid "Type mappings from <literal>java.util.Date</literal> and its subclasses to SQL types <literal>DATE</literal>, <literal>TIME</literal> and <literal>TIMESTAMP</literal> (or equivalent)."
+msgstr "从 <literal>java.util.Date</literal> 和其子类到 SQL 类型 <literal>DATE</literal>，<literal>TIME</literal> å’Œ <literal>TIMESTAMP</literal>ï¼ˆæˆ–ç­‰ä»·ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>calendar, calendar_date</literal>"
-msgstr "calendar, calendar_date"
+msgstr "<literal>calendar, calendar_date</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Type mappings from <literal>java.util.Calendar</literal> to SQL types "
-"<literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
-msgstr ""
-"从 <literal>java.util.Calendar</literal> 到 SQL 类型 <literal>TIMESTAMP</"
-"literal> å’Œ <literal>DATE</literal>ï¼ˆæˆ–ç­‰ä»·ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚"
+msgid "Type mappings from <literal>java.util.Calendar</literal> to SQL types <literal>TIMESTAMP</literal> and <literal>DATE</literal> (or equivalent)."
+msgstr "从 <literal>java.util.Calendar</literal> 到 SQL 类型 <literal>TIMESTAMP</literal> å’Œ <literal>DATE</literal>ï¼ˆæˆ–ç­‰ä»·ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>big_decimal, big_integer</literal>"
-msgstr "big_decimal, big_integer"
+msgstr "<literal>big_decimal, big_integer</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java."
-"math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle "
-"<literal>NUMBER</literal>)."
-msgstr ""
-"从 <literal>java.math.BigDecimal</literal> 和 <literal>java.math.BigInteger</"
-"literal> 到 <literal>NUMERIC</literal>（或者 Oracle 的 <literal>NUMBER</"
-"literal>ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚"
+msgid "Type mappings from <literal>java.math.BigDecimal</literal> and <literal>java.math.BigInteger</literal> to <literal>NUMERIC</literal> (or Oracle <literal>NUMBER</literal>)."
+msgstr "从 <literal>java.math.BigDecimal</literal> å’Œ <literal>java.math.BigInteger</literal> 到 <literal>NUMERIC</literal>（或者 Oracle çš„ <literal>NUMBER</literal>ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>locale, timezone, currency</literal>"
-msgstr "locale, timezone, currency"
+msgstr "<literal>locale, timezone, currency</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Type mappings from <literal>java.util.Locale</literal>, <literal>java.util."
-"TimeZone</literal> and <literal>java.util.Currency</literal> to "
-"<literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). "
-"Instances of <literal>Locale</literal> and <literal>Currency</literal> are "
-"mapped to their ISO codes. Instances of <literal>TimeZone</literal> are "
-"mapped to their <literal>ID</literal>."
-msgstr ""
-"从 <literal>java.util.Locale</literal>，<literal>java.util.TimeZone</"
-"literal>  和 <literal>java.util.Currency</literal> 到 <literal>VARCHAR</"
-"literal>（或者 Oracle çš„ <literal>VARCHAR2</literal> ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚"
-"<literal>Locale</literal> å’Œ <literal>Currency</literal> çš„å®žä¾‹è¢«æ˜ å°„ä¸ºå®ƒä»¬"
-"çš„ ISO ä»£ç ã€‚<literal>TimeZone</literal> 的实例被影射为它的 <literal>ID</"
-"literal>。"
+msgid "Type mappings from <literal>java.util.Locale</literal>, <literal>java.util.TimeZone</literal> and <literal>java.util.Currency</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). Instances of <literal>Locale</literal> and <literal>Currency</literal> are mapped to their ISO codes. Instances of <literal>TimeZone</literal> are mapped to their <literal>ID</literal>."
+msgstr "从 <literal>java.util.Locale</literal>，<literal>java.util.TimeZone</literal>  å’Œ <literal>java.util.Currency</literal> 到 <literal>VARCHAR</literal>（或者 Oracle çš„ <literal>VARCHAR2</literal> ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚<literal>Locale</literal> å’Œ <literal>Currency</literal> çš„å®žä¾‹è¢«æ˜ å°„ä¸ºå®ƒä»¬çš„ ISO ä»£ç ã€‚<literal>TimeZone</literal> 的实例被影射为它的 <literal>ID</literal>。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>class</literal>"
-msgstr "<literal>all（全部）</literal>：检查全部字段"
+msgstr "<literal>class</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</"
-"literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> "
-"is mapped to its fully qualified name."
-msgstr ""
-"从 <literal>java.lang.Class</literal> 到 <literal>VARCHAR</literal>（或者 "
-"Oracle çš„ <literal>VARCHAR2</literal> ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚<literal>Class</literal> "
-"è¢«æ˜ å°„ä¸ºå®ƒçš„å…¨é™å®šåã€‚"
+msgid "A type mapping from <literal>java.lang.Class</literal> to <literal>VARCHAR</literal> (or Oracle <literal>VARCHAR2</literal>). A <literal>Class</literal> is mapped to its fully qualified name."
+msgstr "从 <literal>java.lang.Class</literal> 到 <literal>VARCHAR</literal>（或者 Oracle çš„ <literal>VARCHAR2</literal> ç±»åž‹ï¼‰çš„æ˜ å°„ã€‚<literal>Class</literal> è¢«æ˜ å°„ä¸ºå®ƒçš„å…¨é™å®šåã€‚"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>binary</literal>"
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>binary</literal>"
 
 #. Tag: para
 #, no-c-format
@@ -3387,101 +1701,54 @@
 msgstr "把字节数组（byte arraysï¼‰æ˜ å°„ä¸ºå¯¹åº”çš„ SQL 二进制类型。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>text</literal>"
-msgstr "<literal>name</literal>：属性名"
+msgstr "<literal>text</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</"
-"literal> type."
-msgstr ""
-"把长 Java å­—ç¬¦ä¸²æ˜ å°„ä¸º SQL çš„ <literal>CLOB</literal> 或者 <literal>TEXT</"
-"literal> 类型。"
+msgid "Maps long Java strings to a SQL <literal>CLOB</literal> or <literal>TEXT</literal> type."
+msgstr "把长 Java å­—ç¬¦ä¸²æ˜ å°„ä¸º SQL çš„ <literal>CLOB</literal> 或者 <literal>TEXT</literal> 类型。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>serializable</literal>"
-msgstr "<literal>all（全部）</literal>：检查全部字段"
+msgstr "<literal>serializable</literal>"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Maps serializable Java types to an appropriate SQL binary type. You can also "
-"indicate the Hibernate type <literal>serializable</literal> with the name of "
-"a serializable Java class or interface that does not default to a basic type."
-msgstr ""
-"把可序列化的 Java ç±»åž‹æ˜ å°„åˆ°å¯¹åº”çš„ SQL äºŒè¿›åˆ¶ç±»åž‹ã€‚ä½ ä¹Ÿå¯ä»¥ä¸ºä¸€ä¸ªå¹¶éžé»˜è®¤ä¸ºåŸº"
-"本类型的可序列化 Java 类或者接口指定 Hibernate 类型 <literal>serializable</"
-"literal>。"
+#, no-c-format
+msgid "Maps serializable Java types to an appropriate SQL binary type. You can also indicate the Hibernate type <literal>serializable</literal> with the name of a serializable Java class or interface that does not default to a basic type."
+msgstr "把可序列化的 Java ç±»åž‹æ˜ å°„åˆ°å¯¹åº”çš„ SQL äºŒè¿›åˆ¶ç±»åž‹ã€‚ä½ ä¹Ÿå¯ä»¥ä¸ºä¸€ä¸ªå¹¶éžé»˜è®¤ä¸ºåŸºæœ¬ç±»åž‹çš„å¯åºåˆ—åŒ– Java 类或者接口指定 Hibernate 类型 <literal>serializable</literal>。 "
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>clob, blob</literal>"
-msgstr "<literal>all（全部）</literal>：检查全部字段"
+msgstr "<literal>clob, blob</literal>"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and "
-"<literal>java.sql.Blob</literal>. These types can be inconvenient for some "
-"applications, since the blob or clob object cannot be reused outside of a "
-"transaction. Driver support is patchy and inconsistent."
-msgstr ""
-"JDBC 类 <literal>java.sql.Clob</literal> 和 <literal>java.sql.Blob</literal>"
-"çš„æ˜ å°„ã€‚æŸäº›ç¨‹åºå¯èƒ½ä¸é€‚åˆä½¿ç”¨è¿™ä¸ªç±»åž‹ï¼Œå› ä¸º blob å’Œ clob 对象可能在一个事务"
-"ä¹‹å¤–æ˜¯æ— æ³•é‡ç”¨çš„ã€‚ï¼ˆè€Œä¸”, 驱动程序对这种类型的支持充满着补丁和前后矛盾。）"
+#, no-c-format
+msgid "Type mappings for the JDBC classes <literal>java.sql.Clob</literal> and <literal>java.sql.Blob</literal>. These types can be inconvenient for some applications, since the blob or clob object cannot be reused outside of a transaction. Driver support is patchy and inconsistent."
+msgstr "JDBC ç±» <literal>java.sql.Clob</literal> å’Œ <literal>java.sql.Blob</literal>çš„æ˜ å°„ã€‚æŸäº›ç¨‹åºå¯èƒ½ä¸é€‚åˆä½¿ç”¨è¿™ä¸ªç±»åž‹ï¼Œå› ä¸º blob å’Œ clob å¯¹è±¡å¯èƒ½åœ¨ä¸€ä¸ªäº‹åŠ¡ä¹‹å¤–æ˜¯æ— æ³•é‡ç”¨çš„ã€‚ï¼ˆè€Œä¸”, 驱动程序对这种类型的支持充满着补丁和前后矛盾。） "
 
 #. Tag: term
-#, fuzzy, no-c-format
-msgid ""
-"<literal>imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, "
-"imm_serializable, imm_binary</literal>"
-msgstr ""
-"imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, "
-"imm_serializable, imm_binary"
+#, no-c-format
+msgid "<literal>imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary</literal>"
+msgstr "<literal>imm_date, imm_time, imm_timestamp, imm_calendar, imm_calendar_date, imm_serializable, imm_binary</literal>"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Type mappings for what are considered mutable Java types. This is where "
-"Hibernate makes certain optimizations appropriate only for immutable Java "
-"types, and the application treats the object as immutable. For example, you "
-"should not call <literal>Date.setTime()</literal> for an instance mapped as "
-"<literal>imm_timestamp</literal>. To change the value of the property, and "
-"have that change made persistent, the application must assign a new, "
-"nonidentical, object to the property."
-msgstr ""
-"ä¸€èˆ¬æ¥è¯´ï¼Œæ˜ å°„ç±»åž‹è¢«å‡å®šä¸ºæ˜¯å¯å˜çš„ Java 类型，只有对不可变 Java 类型，"
-"Hibernate 会采取特定的优化措施，应用程序会把这些对象作为不可变对象处理。比"
-"å¦‚ï¼Œä½ ä¸åº”è¯¥å¯¹ä½œä¸º <literal>imm_timestamp</literal> æ˜ å°„çš„ Date 执行 "
-"<literal>Date.setTime()</literal>。要改变属性的值，并且保存这一改变，应用程序"
-"å¿…é¡»å¯¹è¿™ä¸€å±žæ€§é‡æ–°è®¾ç½®ä¸€ä¸ªæ–°çš„ï¼ˆä¸ä¸€æ ·çš„ï¼‰å¯¹è±¡ã€‚"
+#, no-c-format
+msgid "Type mappings for what are considered mutable Java types. This is where Hibernate makes certain optimizations appropriate only for immutable Java types, and the application treats the object as immutable. For example, you should not call <literal>Date.setTime()</literal> for an instance mapped as <literal>imm_timestamp</literal>. To change the value of the property, and have that change made persistent, the application must assign a new, nonidentical, object to the property."
+msgstr "ä¸€èˆ¬æ¥è¯´ï¼Œæ˜ å°„ç±»åž‹è¢«å‡å®šä¸ºæ˜¯å¯å˜çš„ Java 类型，只有对不可变 Java 类型，Hibernate ä¼šé‡‡å–ç‰¹å®šçš„ä¼˜åŒ–æŽªæ–½ï¼Œåº”ç”¨ç¨‹åºä¼šæŠŠè¿™äº›å¯¹è±¡ä½œä¸ºä¸å¯å˜å¯¹è±¡å¤„ç†ã€‚æ¯”å¦‚ï¼Œä½ ä¸åº”è¯¥å¯¹ä½œä¸º <literal>imm_timestamp</literal> æ˜ å°„çš„ Date 执行 <literal>Date.setTime()</literal>ã€‚è¦æ”¹å˜å±žæ€§çš„å€¼ï¼Œå¹¶ä¸”ä¿å­˜è¿™ä¸€æ”¹å˜ï¼Œåº”ç”¨ç¨‹åºå¿…é¡»å¯¹è¿™ä¸€å±žæ€§é‡æ–°è®¾ç½®ä¸€ä¸ªæ–°çš„ï¼ˆä¸ä¸€æ ·çš„ï¼‰å¯¹è±¡ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Unique identifiers of entities and collections can be of any basic type "
-"except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</"
-"literal>. Composite identifiers are also allowed. See below for more "
-"information."
-msgstr ""
-"å®žä½“åŠå…¶é›†åˆçš„å”¯ä¸€æ ‡è¯†å¯ä»¥æ˜¯é™¤äº† <literal>binary</literal>、 <literal>blob</"
-"literal> å’Œ <literal>clob</literal> ä¹‹å¤–çš„ä»»ä½•åŸºç¡€ç±»åž‹ã€‚ï¼ˆè”åˆæ ‡è¯†ä¹Ÿæ˜¯å…è®¸"
-"的，后面会说到。）"
+#, no-c-format
+msgid "Unique identifiers of entities and collections can be of any basic type except <literal>binary</literal>, <literal>blob</literal> and <literal>clob</literal>. Composite identifiers are also allowed. See below for more information."
+msgstr "å®žä½“åŠå…¶é›†åˆçš„å”¯ä¸€æ ‡è¯†å¯ä»¥æ˜¯é™¤äº† <literal>binary</literal>、 <literal>blob</literal> å’Œ <literal>clob</literal> ä¹‹å¤–çš„ä»»ä½•åŸºç¡€ç±»åž‹ã€‚è”åˆæ ‡è¯†ä¹Ÿæ˜¯å…è®¸çš„ï¼Œæˆ‘ä»¬åœ¨åŽé¢ä¼šè¯´åˆ°ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The basic value types have corresponding <literal>Type</literal> constants "
-"defined on <literal>org.hibernate.Hibernate</literal>. For example, "
-"<literal>Hibernate.STRING</literal> represents the <literal>string</literal> "
-"type."
-msgstr ""
-"在 <literal>org.hibernate.Hibernate</literal> 中，定义了基础类型对应的 "
-"<literal>Type</literal> 常量。比如，<literal>Hibernate.STRING</literal> 代表 "
-"<literal>string</literal> 类型。"
+msgid "The basic value types have corresponding <literal>Type</literal> constants defined on <literal>org.hibernate.Hibernate</literal>. For example, <literal>Hibernate.STRING</literal> represents the <literal>string</literal> type."
+msgstr "在 <literal>org.hibernate.Hibernate</literal> 中，定义了基础类型对应的 <literal>Type</literal> 常量。比如，<literal>Hibernate.STRING</literal> 代表 <literal>string</literal> 类型。"
 
 #. Tag: title
 #, no-c-format
@@ -3489,126 +1756,49 @@
 msgstr "自定义值类型"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is relatively easy for developers to create their own value types. For "
-"example, you might want to persist properties of type <literal>java.lang."
-"BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does "
-"not provide a built-in type for this. Custom types are not limited to "
-"mapping a property, or collection element, to a single table column. So, for "
-"example, you might have a Java property <literal>getName()</literal>/"
-"<literal>setName()</literal> of type <literal>java.lang.String</literal> "
-"that is persisted to the columns <literal>FIRST_NAME</literal>, "
-"<literal>INITIAL</literal>, <literal>SURNAME</literal>."
-msgstr ""
-"å¼€å‘è€…åˆ›å»ºå±žäºŽä»–ä»¬è‡ªå·±çš„å€¼ç±»åž‹ä¹Ÿæ˜¯å¾ˆå®¹æ˜“çš„ã€‚æ¯”å¦‚è¯´ï¼Œä½ å¯èƒ½å¸Œæœ›æŒä¹…åŒ– "
-"<literal>java.lang.BigInteger</literal> 类型的属性，持久化成为 "
-"<literal>VARCHAR</literal> 字段。Hibernateæ²¡æœ‰å†…ç½®è¿™æ ·ä¸€ç§ç±»åž‹ã€‚è‡ªå®šä¹‰ç±»åž‹èƒ½"
-"å¤Ÿæ˜ å°„ä¸€ä¸ªå±žæ€§(æˆ–é›†åˆå…ƒç´ )åˆ°ä¸æ­¢ä¸€ä¸ªæ•°æ®åº“è¡¨å­—æ®µã€‚æ¯”å¦‚è¯´ï¼Œä½ å¯èƒ½æœ‰è¿™æ ·çš„ "
-"Java 属性：<literal>getName()</literal>/<literal>setName()</literal>，这是 "
-"<literal>java.lang.String</literal> 类型的，对应的持久化到三个字段："
-"<literal>FIRST_NAME</literal>，<literal>INITIAL</literal>，<literal>SURNAME</"
-"literal>。"
+#, no-c-format
+msgid "It is relatively easy for developers to create their own value types. For example, you might want to persist properties of type <literal>java.lang.BigInteger</literal> to <literal>VARCHAR</literal> columns. Hibernate does not provide a built-in type for this. Custom types are not limited to mapping a property, or collection element, to a single table column. So, for example, you might have a Java property <literal>getName()</literal>/<literal>setName()</literal> of type <literal>java.lang.String</literal> that is persisted to the columns <literal>FIRST_NAME</literal>, <literal>INITIAL</literal>, <literal>SURNAME</literal>."
+msgstr "å¼€å‘è€…åˆ›å»ºå±žäºŽä»–ä»¬è‡ªå·±çš„å€¼ç±»åž‹ä¹Ÿæ˜¯å¾ˆå®¹æ˜“çš„ã€‚æ¯”å¦‚è¯´ï¼Œä½ å¯èƒ½å¸Œæœ›æŒä¹…åŒ– <literal>java.lang.BigInteger</literal> 类型的属性，持久化成为 <literal>VARCHAR</literal> 字段。Hibernateæ²¡æœ‰å†…ç½®è¿™æ ·ä¸€ç§ç±»åž‹ã€‚è‡ªå®šä¹‰ç±»åž‹èƒ½å¤Ÿæ˜ å°„ä¸€ä¸ªå±žæ€§(æˆ–é›†åˆå…ƒç´ )åˆ°ä¸æ­¢ä¸€ä¸ªæ•°æ®åº“è¡¨å­—æ®µã€‚æ¯”å¦‚è¯´ï¼Œä½ å¯èƒ½æœ‰è¿™æ ·çš„ Java 属性：<literal>getName()</literal>/<literal>setName()</literal>，这是 <literal>java.lang.String</literal> 类型的，对应的持久化到三个字段：<literal>FIRST_NAME</literal>、<literal>INITIAL</literal>、<literal>SURNAME</literal>。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"To implement a custom type, implement either <literal>org.hibernate."
-"UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and "
-"declare properties using the fully qualified classname of the type. View "
-"<literal>org.hibernate.test.DoubleStringType</literal> to see the kind of "
-"things that are possible."
-msgstr ""
-"要实现一个自定义类型，可以实现 <literal>org.hibernate.UserType</literal> 或 "
-"<literal>org.hibernate.CompositeUserType</literal> 中的任一个，并且使用类型"
-"的 Java 全限定类名来定义属性。请查看 <literal>org.hibernate.test."
-"DoubleStringType</literal> 这个例子，看看它是怎么做的。"
+#, no-c-format
+msgid "To implement a custom type, implement either <literal>org.hibernate.UserType</literal> or <literal>org.hibernate.CompositeUserType</literal> and declare properties using the fully qualified classname of the type. View <literal>org.hibernate.test.DoubleStringType</literal> to see the kind of things that are possible."
+msgstr "要实现一个自定义类型，可以实现 <literal>org.hibernate.UserType</literal> 或 <literal>org.hibernate.CompositeUserType</literal> 中的任一个，并且使用类型的 Java 全限定类名来定义属性。请查看 <literal>org.hibernate.test.DoubleStringType</literal> 这个例子，看看它是怎么做的。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Notice the use of <literal>&lt;column&gt;</literal> tags to map a property "
-"to multiple columns."
-msgstr ""
-"注意使用 <literal>&lt;column&gt;</literal> æ ‡ç­¾æ¥æŠŠä¸€ä¸ªå±žæ€§æ˜ å°„åˆ°å¤šä¸ªå­—æ®µçš„åš"
-"法。"
+msgid "Notice the use of <literal>&lt;column&gt;</literal> tags to map a property to multiple columns."
+msgstr "注意使用 <literal>&lt;column&gt;</literal> æ ‡ç­¾æ¥æŠŠä¸€ä¸ªå±žæ€§æ˜ å°„åˆ°å¤šä¸ªå­—æ®µçš„åšæ³•ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</"
-"literal>, <literal>UserCollectionType</literal>, and "
-"<literal>UserVersionType</literal> interfaces provide support for more "
-"specialized uses."
-msgstr ""
-"<literal>CompositeUserType</literal>，<literal>EnhancedUserType</literal>，"
-"<literal>UserCollectionType</literal> 和 <literal>UserVersionType</literal> "
-"接口为更特殊的使用方式提供支持。"
+msgid "The <literal>CompositeUserType</literal>, <literal>EnhancedUserType</literal>, <literal>UserCollectionType</literal>, and <literal>UserVersionType</literal> interfaces provide support for more specialized uses."
+msgstr "<literal>CompositeUserType</literal>，<literal>EnhancedUserType</literal>，<literal>UserCollectionType</literal> 和 <literal>UserVersionType</literal> 接口为更特殊的使用方式提供支持。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can even supply parameters to a <literal>UserType</literal> in the "
-"mapping file. To do this, your <literal>UserType</literal> must implement "
-"the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. "
-"To supply parameters to your custom type, you can use the <literal>&lt;"
-"type&gt;</literal> element in your mapping files."
-msgstr ""
-"ä½ ç”šè‡³å¯ä»¥åœ¨ä¸€ä¸ªæ˜ å°„æ–‡ä»¶ä¸­æä¾›å‚æ•°ç»™ä¸€ä¸ª <literal>UserType</literal>。 为了这"
-"æ ·åšï¼Œä½ çš„ <literal>UserType</literal> 必须实现 <literal>org.hibernate."
-"usertype.ParameterizedType</literal> æŽ¥å£ã€‚ä¸ºäº†ç»™è‡ªå®šä¹‰ç±»åž‹æä¾›å‚æ•°ï¼Œä½ å¯ä»¥åœ¨"
-"æ˜ å°„æ–‡ä»¶ä¸­ä½¿ç”¨ <literal>&lt;type&gt;</literal> å…ƒç´ ã€‚"
+#, no-c-format
+msgid "You can even supply parameters to a <literal>UserType</literal> in the mapping file. To do this, your <literal>UserType</literal> must implement the <literal>org.hibernate.usertype.ParameterizedType</literal> interface. To supply parameters to your custom type, you can use the <literal>&lt;type&gt;</literal> element in your mapping files."
+msgstr "ä½ ç”šè‡³å¯ä»¥åœ¨ä¸€ä¸ªæ˜ å°„æ–‡ä»¶ä¸­æä¾›å‚æ•°ç»™ä¸€ä¸ª <literal>UserType</literal>。 ä¸ºäº†è¿™æ ·åšï¼Œä½ çš„ <literal>UserType</literal> 必须实现 <literal>org.hibernate.usertype.ParameterizedType</literal> æŽ¥å£ã€‚ä¸ºäº†ç»™è‡ªå®šä¹‰ç±»åž‹æä¾›å‚æ•°ï¼Œä½ å¯ä»¥åœ¨æ˜ å°„æ–‡ä»¶ä¸­ä½¿ç”¨ <literal>&lt;type&gt;</literal> å…ƒç´ ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>UserType</literal> can now retrieve the value for the parameter "
-"named <literal>default</literal> from the <literal>Properties</literal> "
-"object passed to it."
-msgstr ""
-"现在，<literal>UserType</literal> å¯ä»¥ä»Žä¼ å…¥çš„ <literal>Properties</literal> "
-"对象中得到 <literal>default</literal> 参数的值。"
+msgid "The <literal>UserType</literal> can now retrieve the value for the parameter named <literal>default</literal> from the <literal>Properties</literal> object passed to it."
+msgstr "现在，<literal>UserType</literal> å¯ä»¥ä»Žä¼ å…¥çš„ <literal>Properties</literal> 对象中得到 <literal>default</literal> 参数的值。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If you regularly use a certain <literal>UserType</literal>, it is useful to "
-"define a shorter name for it. You can do this using the <literal>&lt;"
-"typedef&gt;</literal> element. Typedefs assign a name to a custom type, and "
-"can also contain a list of default parameter values if the type is "
-"parameterized."
-msgstr ""
-"å¦‚æžœä½ éžå¸¸é¢‘ç¹åœ°ä½¿ç”¨æŸä¸€ <literal>UserType</literal>，可以为他定义一个简称。"
-"这可以通过使用 <literal>&lt;typedef&gt;</literal> å…ƒç´ æ¥å®žçŽ°ã€‚Typedefs 为一自"
-"定义类型赋予一个名称，并且如果此类型是参数化的，还可以包含一系列默认的参数"
-"值。"
+#, no-c-format
+msgid "If you regularly use a certain <literal>UserType</literal>, it is useful to define a shorter name for it. You can do this using the <literal>&lt;typedef&gt;</literal> element. Typedefs assign a name to a custom type, and can also contain a list of default parameter values if the type is parameterized."
+msgstr "å¦‚æžœä½ éžå¸¸é¢‘ç¹åœ°ä½¿ç”¨æŸä¸€ <literal>UserType</literal>，可以为他定义一个简称。这可以通过使用 <literal>&lt;typedef&gt;</literal> å…ƒç´ æ¥å®žçŽ°ã€‚Typedefs 为一自定义类型赋予一个名称，并且如果此类型是参数化的，还可以包含一系列默认的参数值。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is also possible to override the parameters supplied in a typedef on a "
-"case-by-case basis by using type parameters on the property mapping."
-msgstr ""
-"ä¹Ÿå¯ä»¥æ ¹æ®å…·ä½“æ¡ˆä¾‹é€šè¿‡å±žæ€§æ˜ å°„ä¸­çš„ç±»åž‹å‚æ•°è¦†ç›–åœ¨ typedef 中提供的参数。"
+msgid "It is also possible to override the parameters supplied in a typedef on a case-by-case basis by using type parameters on the property mapping."
+msgstr "ä¹Ÿå¯ä»¥æ ¹æ®å…·ä½“æ¡ˆä¾‹é€šè¿‡å±žæ€§æ˜ å°„ä¸­çš„ç±»åž‹å‚æ•°è¦†ç›–åœ¨ typedef 中提供的参数。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Even though Hibernate's rich range of built-in types and support for "
-"components means you will rarely need to use a custom type, it is considered "
-"good practice to use custom types for non-entity classes that occur "
-"frequently in your application. For example, a <literal>MonetaryAmount</"
-"literal> class is a good candidate for a <literal>CompositeUserType</"
-"literal>, even though it could be mapped as a component. One reason for this "
-"is abstraction. With a custom type, your mapping documents would be "
-"protected against changes to the way monetary values are represented."
-msgstr ""
-"尽管 Hibernate å†…å»ºçš„ä¸°å¯Œçš„ç±»åž‹å’Œå¯¹ç»„ä»¶çš„æ”¯æŒæ„å‘³ç€ä½ å¯èƒ½å¾ˆå°‘ <emphasis>需要"
-"</emphasis>ä½¿ç”¨è‡ªå®šä¹‰ç±»åž‹ã€‚ä¸è¿‡ï¼Œä¸ºé‚£äº›åœ¨ä½ çš„åº”ç”¨ä¸­ç»å¸¸å‡ºçŽ°çš„(非实体)类使用自"
-"定义类型也是一个好方法。例如，一个 <literal>MonetaryAmount</literal> 类使用 "
-"<literal>CompositeUserType</literal> æ¥æ˜ å°„æ˜¯ä¸é”™çš„é€‰æ‹©ï¼Œè™½ç„¶ä»–å¯ä»¥å¾ˆå®¹æ˜“åœ°è¢«"
-"æ˜ å°„æˆç»„ä»¶ã€‚è¿™æ ·åšçš„åŠ¨æœºä¹‹ä¸€æ˜¯æŠ½è±¡ã€‚ä½¿ç”¨è‡ªå®šä¹‰ç±»åž‹ï¼Œä»¥åŽå‡è‹¥ä½ æ”¹å˜è¡¨ç¤ºé‡‘é¢çš„"
-"æ–¹æ³•æ—¶ï¼Œå®ƒå¯ä»¥ä¿è¯æ˜ å°„æ–‡ä»¶ä¸éœ€è¦ä¿®æ”¹ã€‚"
+#, no-c-format
+msgid "Even though Hibernate's rich range of built-in types and support for components means you will rarely need to use a custom type, it is considered good practice to use custom types for non-entity classes that occur frequently in your application. For example, a <literal>MonetaryAmount</literal> class is a good candidate for a <literal>CompositeUserType</literal>, even though it could be mapped as a component. One reason for this is abstraction. With a custom type, your mapping documents would be protected against changes to the way monetary values are represented."
+msgstr "尽管 Hibernate å†…å»ºçš„ä¸°å¯Œçš„ç±»åž‹å’Œå¯¹ç»„ä»¶çš„æ”¯æŒæ„å‘³ç€ä½ å¯èƒ½å¾ˆå°‘ <emphasis>需要</emphasis>ä½¿ç”¨è‡ªå®šä¹‰ç±»åž‹ã€‚ä¸è¿‡ï¼Œä¸ºé‚£äº›åœ¨ä½ çš„åº”ç”¨ä¸­ç»å¸¸å‡ºçŽ°çš„(非实体)类使用自定义类型也是一个好方法。例如，一个 <literal>MonetaryAmount</literal> 类使用 <literal>CompositeUserType</literal> æ¥æ˜ å°„æ˜¯ä¸é”™çš„é€‰æ‹©ï¼Œè™½ç„¶ä»–å¯ä»¥å¾ˆå®¹æ˜“åœ°è¢«æ˜ å°„æˆç»„ä»¶ã€‚è¿™æ ·åšçš„åŠ¨æœºä¹‹ä¸€æ˜¯æŠ½è±¡ã€‚ä½¿ç”¨è‡ªå®šä¹‰ç±»åž‹ï¼Œä»¥åŽå‡è‹¥ä½ æ”¹å˜è¡¨ç¤ºé‡‘é¢çš„æ–¹æ³•æ—¶ï¼Œå®ƒå¯ä»¥ä¿è¯æ˜ å°„æ–‡ä»¶ä¸éœ€è¦ä¿®æ”¹ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -3616,28 +1806,14 @@
 msgstr "å¤šæ¬¡æ˜ å°„åŒä¸€ä¸ªç±»"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is possible to provide more than one mapping for a particular persistent "
-"class. In this case, you must specify an <emphasis>entity name</emphasis> to "
-"disambiguate between instances of the two mapped entities. By default, the "
-"entity name is the same as the class name. Hibernate lets you specify the "
-"entity name when working with persistent objects, when writing queries, or "
-"when mapping associations to the named entity."
-msgstr ""
-"å¯¹ç‰¹å®šçš„æŒä¹…åŒ–ç±»ï¼Œæ˜ å°„å¤šæ¬¡æ˜¯å…è®¸çš„ã€‚è¿™ç§æƒ…å½¢ä¸‹ï¼Œä½ å¿…é¡»æŒ‡å®š <emphasis>entity "
-"name</emphasis> æ¥åŒºåˆ«ä¸åŒæ˜ å°„å®žä½“çš„å¯¹è±¡å®žä¾‹ã€‚ï¼ˆé»˜è®¤æƒ…å†µä¸‹ï¼Œå®žä½“åå­—å’Œç±»åæ˜¯"
-"相同的。） Hibernate åœ¨æ“ä½œæŒä¹…åŒ–å¯¹è±¡ã€ç¼–å†™æŸ¥è¯¢æ¡ä»¶ï¼Œæˆ–è€…æŠŠå…³è”æ˜ å°„åˆ°æŒ‡å®šå®žä½“"
-"æ—¶ï¼Œå…è®¸ä½ æŒ‡å®šè¿™ä¸ª entity name（实体名字）。"
+#, no-c-format
+msgid "It is possible to provide more than one mapping for a particular persistent class. In this case, you must specify an <emphasis>entity name</emphasis> to disambiguate between instances of the two mapped entities. By default, the entity name is the same as the class name. Hibernate lets you specify the entity name when working with persistent objects, when writing queries, or when mapping associations to the named entity."
+msgstr "å¯¹ç‰¹å®šçš„æŒä¹…åŒ–ç±»ï¼Œæ˜ å°„å¤šæ¬¡æ˜¯å…è®¸çš„ã€‚è¿™ç§æƒ…å½¢ä¸‹ï¼Œä½ å¿…é¡»æŒ‡å®š <emphasis>entity name</emphasis> æ¥åŒºåˆ«ä¸åŒæ˜ å°„å®žä½“çš„å¯¹è±¡å®žä¾‹ã€‚ï¼ˆé»˜è®¤æƒ…å†µä¸‹ï¼Œå®žä½“åå­—å’Œç±»åæ˜¯ç›¸åŒçš„ã€‚ï¼‰ Hibernate åœ¨æ“ä½œæŒä¹…åŒ–å¯¹è±¡ã€ç¼–å†™æŸ¥è¯¢æ¡ä»¶ï¼Œæˆ–è€…æŠŠå…³è”æ˜ å°„åˆ°æŒ‡å®šå®žä½“æ—¶ï¼Œå…è®¸ä½ æŒ‡å®šè¿™ä¸ª entity name（实体名字）。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Associations are now specified using <literal>entity-name</literal> instead "
-"of <literal>class</literal>."
-msgstr ""
-"注意这里关联是如何用 <literal>entity-name</literal> 来代替 <literal>class</"
-"literal> 的。"
+#, no-c-format
+msgid "Associations are now specified using <literal>entity-name</literal> instead of <literal>class</literal>."
+msgstr "注意这里关联是如何用 <literal>entity-name</literal> 来代替 <literal>class</literal> 的。 "
 
 #. Tag: title
 #, no-c-format
@@ -3645,18 +1821,9 @@
 msgstr "SQL ä¸­å¼•å·åŒ…å›´çš„æ ‡è¯†ç¬¦"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can force Hibernate to quote an identifier in the generated SQL by "
-"enclosing the table or column name in backticks in the mapping document. "
-"Hibernate will use the correct quotation style for the SQL <literal>Dialect</"
-"literal>. This is usually double quotes, but the SQL Server uses brackets "
-"and MySQL uses backticks."
-msgstr ""
-"ä½ å¯é€šè¿‡åœ¨æ˜ å°„æ–‡æ¡£ä¸­ä½¿ç”¨åå‘å¼•å·ï¼ˆ`）把表名或者字段名包围起来，以强制 "
-"Hibernate 在生成的 SQL ä¸­æŠŠæ ‡è¯†ç¬¦ç”¨å¼•å·åŒ…å›´èµ·æ¥ã€‚Hibernate 会使用相应的 "
-"SQL<literal>Dialect</literal>ï¼ˆæ–¹è¨€ï¼‰æ¥ä½¿ç”¨æ­£ç¡®çš„å¼•å·é£Žæ ¼(通常是双引号，但是"
-"在 SQL Server 中是括号，MySQL 中是反向引号)。"
+#, no-c-format
+msgid "You can force Hibernate to quote an identifier in the generated SQL by enclosing the table or column name in backticks in the mapping document. Hibernate will use the correct quotation style for the SQL <literal>Dialect</literal>. This is usually double quotes, but the SQL Server uses brackets and MySQL uses backticks."
+msgstr "ä½ å¯é€šè¿‡åœ¨æ˜ å°„æ–‡æ¡£ä¸­ä½¿ç”¨åå‘å¼•å·ï¼ˆ`）把表名或者字段名包围起来，以强制 Hibernate 在生成的 SQL ä¸­æŠŠæ ‡è¯†ç¬¦ç”¨å¼•å·åŒ…å›´èµ·æ¥ã€‚Hibernate 会使用相应的 SQL<literal>Dialect</literal>ï¼ˆæ–¹è¨€ï¼‰æ¥ä½¿ç”¨æ­£ç¡®çš„å¼•å·é£Žæ ¼(通常是双引号，但是在 SQL Server 中是括号，MySQL 中是反向引号)。 "
 
 #. Tag: title
 #, no-c-format
@@ -3664,13 +1831,9 @@
 msgstr "其他元数据（Metadata）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"XML does not suit all users so there are some alternative ways to define O/R "
-"mapping metadata in Hibernate."
-msgstr ""
-"XML 并不适用于所有人, å› æ­¤æœ‰å…¶ä»–å®šä¹‰ Hibernate O/R æ˜ å°„å…ƒæ•°æ®ï¼ˆmetadata）的方"
-"法。"
+#, no-c-format
+msgid "XML does not suit all users so there are some alternative ways to define O/R mapping metadata in Hibernate."
+msgstr "XML 并不适用于所有人, å› æ­¤æœ‰å…¶ä»–å®šä¹‰ Hibernate O/R æ˜ å°„å…ƒæ•°æ®ï¼ˆmetadata）的方法。 "
 
 #. Tag: title
 #, no-c-format
@@ -3678,23 +1841,14 @@
 msgstr "使用 XDoclet æ ‡è®°"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Many Hibernate users prefer to embed mapping information directly in "
-"sourcecode using XDoclet <literal>@hibernate.tags</literal>. We do not cover "
-"this approach in this reference guide since it is considered part of "
-"XDoclet. However, we include the following example of the <literal>Cat</"
-"literal> class with XDoclet mappings:"
-msgstr ""
-"很多 Hibernate 使用者更喜欢使用 XDoclet<literal>@hibernate.tags</literal> 将"
-"æ˜ å°„ä¿¡æ¯ç›´æŽ¥åµŒå…¥åˆ°æºä»£ç ä¸­ã€‚æˆ‘ä»¬ä¸ä¼šåœ¨æœ¬æ–‡æ¡£ä¸­æ¶‰åŠè¿™ä¸ªæ–¹æ³•ï¼Œå› ä¸ºä¸¥æ ¼è¯´æ¥ï¼Œè¿™"
-"属于 XDoclet 的一部分。然而，我们包含了如下使用 XDoclet æ˜ å°„çš„ <literal>Cat</"
-"literal> 类的例子。"
+#, no-c-format
+msgid "Many Hibernate users prefer to embed mapping information directly in sourcecode using XDoclet <literal>@hibernate.tags</literal>. We do not cover this approach in this reference guide since it is considered part of XDoclet. However, we include the following example of the <literal>Cat</literal> class with XDoclet mappings:"
+msgstr "很多 Hibernate 使用者更喜欢使用 XDoclet<literal>@hibernate.tags</literal> å°†æ˜ å°„ä¿¡æ¯ç›´æŽ¥åµŒå…¥åˆ°æºä»£ç ä¸­ã€‚æˆ‘ä»¬ä¸ä¼šåœ¨æœ¬æ–‡æ¡£ä¸­æ¶‰åŠè¿™ä¸ªæ–¹æ³•ï¼Œå› ä¸ºä¸¥æ ¼è¯´æ¥ï¼Œè¿™å±žäºŽ XDoclet 的一部分。然而，我们包含了如下使用 XDoclet æ˜ å°„çš„ <literal>Cat</literal> 类的例子。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "See the Hibernate website for more examples of XDoclet and Hibernate."
-msgstr "参考 Hibernate 网站更多的 Xdoclet 和 Hibernate 的例子"
+msgstr "参考 Hibernate 网站更多的 Xdoclet 和 Hibernate 的例子。"
 
 #. Tag: title
 #, no-c-format
@@ -3702,26 +1856,9 @@
 msgstr "使用 JDK 5.0 的注解（Annotation）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"JDK 5.0 introduced XDoclet-style annotations at the language level that are "
-"type-safe and checked at compile time. This mechanism is more powerful than "
-"XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, "
-"for example, supports auto-completion and syntax highlighting of JDK 5.0 "
-"annotations. The new revision of the EJB specification (JSR-220) uses JDK "
-"5.0 annotations as the primary metadata mechanism for entity beans. "
-"Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the "
-"persistence API). Support for mapping metadata is available via the "
-"<emphasis>Hibernate Annotations</emphasis> package as a separate download. "
-"Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
-msgstr ""
-"JDK 5.0 在语言级别引入了 XDoclet é£Žæ ¼çš„æ ‡æ³¨ï¼Œå¹¶ä¸”æ˜¯ç±»åž‹å®‰å…¨çš„ï¼Œåœ¨ç¼–è¯‘æœŸè¿›è¡Œæ£€"
-"查。这一机制比 XDoclet 的注解更为强大，有更好的工具和 IDE 支持。例如，"
-"IntelliJ IDEA，支持 JDK 5.0 注解的自动完成和语法高亮 。EJB 规范的新修订版 "
-"(JSR-220) 使用 JDK 5.0 的注解作为entity beans的主要元数据（metadata）机制。"
-"Hibernate 3 实现了JSR-220(the persistence API) 的 <literal>EntityManager</"
-"literal>，支持通过 <emphasis>Hibernate Annotations</emphasis> åŒ…å®šä¹‰æ˜ å°„å…ƒæ•°"
-"据。这个包作为单独的部分下载，支持 EJB3(JSR-220) 和 Hibernate3 的元数据。"
+#, no-c-format
+msgid "JDK 5.0 introduced XDoclet-style annotations at the language level that are type-safe and checked at compile time. This mechanism is more powerful than XDoclet annotations and better supported by tools and IDEs. IntelliJ IDEA, for example, supports auto-completion and syntax highlighting of JDK 5.0 annotations. The new revision of the EJB specification (JSR-220) uses JDK 5.0 annotations as the primary metadata mechanism for entity beans. Hibernate3 implements the <literal>EntityManager</literal> of JSR-220 (the persistence API). Support for mapping metadata is available via the <emphasis>Hibernate Annotations</emphasis> package as a separate download. Both EJB3 (JSR-220) and Hibernate3 metadata is supported."
+msgstr "JDK 5.0 在语言级别引入了 XDoclet é£Žæ ¼çš„æ ‡æ³¨ï¼Œå¹¶ä¸”æ˜¯ç±»åž‹å®‰å…¨çš„ï¼Œåœ¨ç¼–è¯‘æœŸè¿›è¡Œæ£€æŸ¥ã€‚è¿™ä¸€æœºåˆ¶æ¯” XDoclet 的注解更为强大，有更好的工具和 IDE 支持。例如，IntelliJ IDEA，支持 JDK 5.0 注解的自动完成和语法高亮 。EJB 规范的新修订版 (JSR-220) 使用 JDK 5.0 的注解作为entity beans的主要元数据（metadata）机制。Hibernate 3 实现了JSR-220(the persistence API) çš„ <literal>EntityManager</literal>，支持通过 <emphasis>Hibernate Annotations</emphasis> åŒ…å®šä¹‰æ˜ å°„å…ƒæ•°æ®ã€‚è¿™ä¸ªåŒ…ä½œä¸ºå•ç‹¬çš„éƒ¨åˆ†ä¸‹è½½ï¼Œæ”¯æŒ EJB3(JSR-220) å’Œ Hibernate3 的元数据。 "
 
 #. Tag: para
 #, no-c-format
@@ -3729,129 +1866,64 @@
 msgstr "这是一个被注解为 EJB entity bean 的 POJO 类的例子"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Support for JDK 5.0 Annotations (and JSR-220) is currently under "
-"development. Please refer to the Hibernate Annotations module for more "
-"details."
-msgstr ""
-"注意：对 JDK 5.0 注解（和 JSR-220)支持的工作仍然在进行中,并未完成。更多细节请"
-"参阅 Hibernate Annotations 模块。"
+#, no-c-format
+msgid "Support for JDK 5.0 Annotations (and JSR-220) is currently under development. Please refer to the Hibernate Annotations module for more details."
+msgstr "注意：对 JDK 5.0 注解（和 JSR-220)支持的工作仍然在进行中,并未完成。更多细节请参阅 Hibernate Annotations 模块。 "
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Generated properties"
-msgstr "数据库生成属性（Generated Properties）"
+msgstr "数据库生成属性（Generated Properties） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Generated properties are properties that have their values generated by the "
-"database. Typically, Hibernate applications needed to <literal>refresh</"
-"literal> objects that contain any properties for which the database was "
-"generating values. Marking properties as generated, however, lets the "
-"application delegate this responsibility to Hibernate. When Hibernate issues "
-"an SQL INSERT or UPDATE for an entity that has defined generated properties, "
-"it immediately issues a select afterwards to retrieve the generated values."
-msgstr ""
-"Generated properties 指的是其值由数据库生成的属性。一般来说，如果对象有任何属"
-"性由数据库生成值，Hibernate 应用程序需要进行<literal>刷新（refresh）</"
-"literal>ã€‚ä½†å¦‚æžœæŠŠå±žæ€§æ ‡æ˜Žä¸º generated，就可以转由 Hibernate 来负责这个动作。"
-"实际上。对定义了 generated properties 的实体,每当 Hibernate 执行一条 SQL "
-"INSERT 或者 UPDATE 语句，会立刻执行一条 select 来获得生成的值。"
+#, no-c-format
+msgid "Generated properties are properties that have their values generated by the database. Typically, Hibernate applications needed to <literal>refresh</literal> objects that contain any properties for which the database was generating values. Marking properties as generated, however, lets the application delegate this responsibility to Hibernate. When Hibernate issues an SQL INSERT or UPDATE for an entity that has defined generated properties, it immediately issues a select afterwards to retrieve the generated values."
+msgstr "Generated properties 指的是其值由数据库生成的属性。一般来说，如果对象有任何属性由数据库生成值，Hibernate 应用程序需要进行<literal>刷新（refresh）</literal>ã€‚ä½†å¦‚æžœæŠŠå±žæ€§æ ‡æ˜Žä¸º generated，就可以转由 Hibernate 来负责这个动作。实际上。对定义了 generated properties 的实体,每当 Hibernate 执行一条 SQL INSERT 或者 UPDATE 语句，会立刻执行一条 select 来获得生成的值。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Properties marked as generated must additionally be non-insertable and non-"
-"updateable. Only <xref linkend=\"mapping-declaration-version\" />, <xref "
-"linkend=\"mapping-declaration-timestamp\" />, and <xref linkend=\"mapping-"
-"declaration-property\" />, can be marked as generated."
-msgstr ""
-"è¢«æ ‡æ˜Žä¸º generated 的属性还必须是 non-insertable å’Œ non-updateable 的。只有 "
-"<xref linkend=\"Mapping_declaration-version_optional\"/> versions、<xref "
-"linkend=\"Mapping_declaration-timestamp_optional\"/> timestamp 和 <xref "
-"linkend=\"Mapping_declaration-property\"/> 简单属性（simple properties）可以"
-"è¢«æ ‡æ˜Žä¸º generated。"
+#, no-c-format
+msgid "Properties marked as generated must additionally be non-insertable and non-updateable. Only <xref linkend=\"mapping-declaration-version\" />, <xref linkend=\"mapping-declaration-timestamp\" />, and <xref linkend=\"mapping-declaration-property\" />, can be marked as generated."
+msgstr "è¢«æ ‡æ˜Žä¸º generated 的属性还必须是 non-insertable å’Œ non-updateable 的。只有 <xref linkend=\"mapping_declaration-version_optional\"/> versions、<xref linkend=\"mapping_declaration-timestamp_optional\"/> timestamp å’Œ <xref linkend=\"mapping_declaration-property\"/> 简单属性（simple propertiesï¼‰å¯ä»¥è¢«æ ‡æ˜Žä¸º generated。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>never</literal> (the default): the given property value is not "
-"generated within the database."
-msgstr "<literal>never</literal>ï¼ˆé»˜è®¤ï¼‰æ ‡æ˜Žæ­¤å±žæ€§å€¼ä¸æ˜¯ä»Žæ•°æ®åº“ä¸­ç”Ÿæˆã€‚"
+#, no-c-format
+msgid "<literal>never</literal> (the default): the given property value is not generated within the database."
+msgstr "<literal>never</literal>ï¼ˆé»˜è®¤ï¼‰æ ‡æ˜Žæ­¤å±žæ€§å€¼ä¸æ˜¯ä»Žæ•°æ®åº“ä¸­ç”Ÿæˆã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>insert</literal>: the given property value is generated on insert, "
-"but is not regenerated on subsequent updates. Properties like created-date "
-"fall into this category. Even though <xref linkend=\"mapping-declaration-"
-"version\" /> and <xref linkend=\"mapping-declaration-timestamp\" /> "
-"properties can be marked as generated, this option is not available."
-msgstr ""
-"<literal>insert</literal> — æ ‡æ˜Žæ­¤å±žæ€§å€¼åœ¨ insert 的时候生成，但是不会在随后"
-"的 update 时重新生成。比如说创建日期就归属于这类。注意虽然 <xref linkend="
-"\"Mapping_declaration-version_optional\"/> version 和 <xref linkend="
-"\"Mapping_declaration-timestamp_optional\"/> timestamp å±žæ€§å¯ä»¥è¢«æ ‡æ³¨ä¸º "
-"generated，但是不适用这个选项..."
+#, no-c-format
+msgid "<literal>insert</literal>: the given property value is generated on insert, but is not regenerated on subsequent updates. Properties like created-date fall into this category. Even though <xref linkend=\"mapping-declaration-version\" /> and <xref linkend=\"mapping-declaration-timestamp\" /> properties can be marked as generated, this option is not available."
+msgstr "<literal>insert</literal> — æ ‡æ˜Žæ­¤å±žæ€§å€¼åœ¨ insert 的时候生成，但是不会在随后的 update 时重新生成。比如说创建日期就归属于这类。注意虽然 <xref linkend=\"mapping-declaration-version\" /> version å’Œ <xref linkend=\"mapping-declaration-timestamp\" /> timestamp å±žæ€§å¯ä»¥è¢«æ ‡æ³¨ä¸º generated，但是不适用这个选项..."
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>always</literal>: the property value is generated both on insert "
-"and on update."
-msgstr ""
-"<literal>always</literal> — æ ‡æ˜Žæ­¤å±žæ€§å€¼åœ¨ insert å’Œ update 时都会被生成。"
+#, no-c-format
+msgid "<literal>always</literal>: the property value is generated both on insert and on update."
+msgstr "<literal>always</literal>ï¼šæ ‡æ˜Žæ­¤å±žæ€§å€¼åœ¨ insert å’Œ update 时都会被生成。"
 
 #. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "Auxiliary database objects"
-msgstr "辅助数据库对象（Auxiliary Database Objects）"
+msgstr "辅助数据库对象（Auxiliary Database Objects） "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Auxiliary database objects allow for the CREATE and DROP of arbitrary "
-"database objects. In conjunction with Hibernate's schema evolution tools, "
-"they have the ability to fully define a user schema within the Hibernate "
-"mapping files. Although designed specifically for creating and dropping "
-"things like triggers or stored procedures, any SQL command that can be run "
-"via a <literal>java.sql.Statement.execute()</literal> method is valid (for "
-"example, ALTERs, INSERTS, etc.). There are essentially two modes for "
-"defining auxiliary database objects:"
-msgstr ""
-"允许 CREATE 和 DROP 任意数据库对象，与 Hibernate 的 schema 交互工具组合起来，"
-"可以提供在 Hibernate æ˜ å°„æ–‡ä»¶ä¸­å®Œå…¨å®šä¹‰ç”¨æˆ· schema 的能力。虽然这是为创建和销"
-"毁 trigger（触发器）或stored procedure（存储过程）等特别设计的，实际上任何可"
-"以在 <literal>java.sql.Statement.execute()</literal> 方法中执行的 SQL 命令都"
-"可以在此使用（比如ALTER, INSERT，等等）。本质上有两种模式来定义辅助数据库对"
-"象..."
+#, no-c-format
+msgid "Auxiliary database objects allow for the CREATE and DROP of arbitrary database objects. In conjunction with Hibernate's schema evolution tools, they have the ability to fully define a user schema within the Hibernate mapping files. Although designed specifically for creating and dropping things like triggers or stored procedures, any SQL command that can be run via a <literal>java.sql.Statement.execute()</literal> method is valid (for example, ALTERs, INSERTS, etc.). There are essentially two modes for defining auxiliary database objects:"
+msgstr "允许 CREATE å’Œ DROP 任意数据库对象，与 Hibernate çš„ schema 交互工具组合起来，可以提供在 Hibernate æ˜ å°„æ–‡ä»¶ä¸­å®Œå…¨å®šä¹‰ç”¨æˆ· schema 的能力。虽然这是为创建和销毁 trigger（触发器）或stored procedure（存储过程）等特别设计的，实际上任何可以在 <literal>java.sql.Statement.execute()</literal> 方法中执行的 SQL 命令都可以在此使用（比如ALTER, INSERT，等等）。本质上有两种模式来定义辅助数据库对象："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The first mode is to explicitly list the CREATE and DROP commands in the "
-"mapping file:"
-msgstr "ç¬¬ä¸€ç§æ¨¡å¼æ˜¯åœ¨æ˜ å°„æ–‡ä»¶ä¸­æ˜¾å¼å£°æ˜Ž CREATE å’Œ DROP 命令："
+#, no-c-format
+msgid "The first mode is to explicitly list the CREATE and DROP commands in the mapping file:"
+msgstr "ç¬¬ä¸€ç§æ¨¡å¼æ˜¯åœ¨æ˜ å°„æ–‡ä»¶ä¸­æ˜¾å¼å£°æ˜Ž CREATE å’Œ DROP 命令： "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The second mode is to supply a custom class that constructs the CREATE and "
-"DROP commands. This custom class must implement the <literal>org.hibernate."
-"mapping.AuxiliaryDatabaseObject</literal> interface."
-msgstr ""
-"第二种模式是提供一个类，这个类知道如何组织 CREATE 和 DROP 命令。这个特别类必"
-"须实现 <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> 接"
-"口。"
+#, no-c-format
+msgid "The second mode is to supply a custom class that constructs the CREATE and DROP commands. This custom class must implement the <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> interface."
+msgstr "第二种模式是提供一个类，这个类知道如何组织 CREATE 和 DROP 命令。这个特别类必须实现 <literal>org.hibernate.mapping.AuxiliaryDatabaseObject</literal> 接口。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Additionally, these database objects can be optionally scoped so that they "
-"only apply when certain dialects are used."
-msgstr "还有，这些数据库对象可以特别指定为仅在特定的方言中才使用。"
+#, no-c-format
+msgid "Additionally, these database objects can be optionally scoped so that they only apply when certain dialects are used."
+msgstr "还有，这些数据库对象可以特别指定为仅在特定的方言中才使用。 "
 
 #~ msgid ""
 #~ "<![CDATA[<?xml version=\"1.0\"?>\n"
@@ -3985,7 +2057,6 @@
 #~ "        </class>\n"
 #~ "\n"
 #~ "</hibernate-mapping>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<?xml version=\"1.0\"?>\n"
 #~ "<!DOCTYPE hibernate-mapping PUBLIC\n"
@@ -4018,7 +2089,6 @@
 #~ "    <class>\n"
 #~ "    &types;\n"
 #~ "</hibernate-mapping>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<hibernate-mapping\n"
 #~ "         schema=\"schemaName\"\n"
@@ -4039,7 +2109,6 @@
 #~ "         auto-import=\"true|false\"\n"
 #~ "         package=\"package.name\"\n"
 #~ " />]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<class\n"
 #~ "        name=\"ClassName\"\n"
@@ -4090,7 +2159,6 @@
 #~ "        abstract=\"true|false\"\n"
 #~ "        node=\"element-name\"\n"
 #~ "/>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<class name=\"Summary\">\n"
 #~ "    <subselect>\n"
@@ -4117,7 +2185,6 @@
 #~ "    <id name=\"name\"/>\n"
 #~ "    ...\n"
 #~ "</class>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<id\n"
 #~ "        name=\"propertyName\"\n"
@@ -4140,7 +2207,6 @@
 #~ "\n"
 #~ "        <generator class=\"generatorClass\"/>\n"
 #~ "</id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
 #~ "        <generator class=\"org.hibernate.id.TableHiLoGenerator\">\n"
@@ -4155,37 +2221,26 @@
 #~ "                <param name=\"column\">next_hi_value_column</param>\n"
 #~ "        </generator>\n"
 #~ "</id>]]>"
-
 #~ msgid "increment"
 #~ msgstr "increment"
-
 #~ msgid "identity"
 #~ msgstr "identity"
-
 #~ msgid "sequence"
 #~ msgstr "sequence"
-
 #~ msgid "hilo"
 #~ msgstr "hilo"
-
 #~ msgid "seqhilo"
 #~ msgstr "seqhilo"
-
 #~ msgid "guid"
 #~ msgstr "guid"
-
 #~ msgid "native"
 #~ msgstr "native"
-
 #~ msgid "assigned"
 #~ msgstr "assigned"
-
 #~ msgid "select"
 #~ msgstr "select"
-
 #~ msgid "foreign"
 #~ msgstr "foreign"
-
 #~ msgid ""
 #~ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
 #~ "        <generator class=\"hilo\">\n"
@@ -4202,7 +2257,6 @@
 #~ "                <param name=\"max_lo\">100</param>\n"
 #~ "        </generator>\n"
 #~ "</id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<id name=\"id\" type=\"long\" column=\"cat_id\">\n"
 #~ "        <generator class=\"seqhilo\">\n"
@@ -4217,7 +2271,6 @@
 #~ "                <param name=\"max_lo\">100</param>\n"
 #~ "        </generator>\n"
 #~ "</id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
 #~ "        <generator class=\"sequence\">\n"
@@ -4230,7 +2283,6 @@
 #~ "                <param name=\"sequence\">person_id_sequence</param>\n"
 #~ "        </generator>\n"
 #~ "</id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\" unsaved-value="
 #~ "\"0\">\n"
@@ -4241,7 +2293,6 @@
 #~ "\"0\">\n"
 #~ "        <generator class=\"identity\"/>\n"
 #~ "</id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<id name=\"id\" type=\"long\" column=\"person_id\">\n"
 #~ "        <generator class=\"select\">\n"
@@ -4254,7 +2305,6 @@
 #~ "                <param name=\"key\">socialSecurityNumber</param>\n"
 #~ "        </generator>\n"
 #~ "</id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<composite-id\n"
 #~ "        name=\"propertyName\"\n"
@@ -4283,7 +2333,6 @@
 #~ "\"column_name\"/>\n"
 #~ "        ......\n"
 #~ "</composite-id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<composite-id>\n"
 #~ "        <key-property name=\"medicareNumber\"/>\n"
@@ -4294,7 +2343,6 @@
 #~ "        <key-property name=\"medicareNumber\"/>\n"
 #~ "        <key-property name=\"dependent\"/>\n"
 #~ "</composite-id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
 #~ "        <key-property name=\"medicareNumber\"/>\n"
@@ -4305,7 +2353,6 @@
 #~ "        <key-property name=\"medicareNumber\"/>\n"
 #~ "        <key-property name=\"dependent\"/>\n"
 #~ "</composite-id>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<discriminator\n"
 #~ "        column=\"discriminator_column\"\n"
@@ -4322,7 +2369,6 @@
 #~ "        insert=\"true|false\"\n"
 #~ "        formula=\"arbitrary sql expression\"\n"
 #~ "/>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<discriminator\n"
 #~ "    formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end"
@@ -4333,7 +2379,6 @@
 #~ "    formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end"
 #~ "\"\n"
 #~ "    type=\"integer\"/>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<version\n"
 #~ "        column=\"version_column\"\n"
@@ -4356,7 +2401,6 @@
 #~ "        insert=\"true|false\"\n"
 #~ "        node=\"element-name|@attribute-name|element/@attribute|.\"\n"
 #~ "/>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<timestamp\n"
 #~ "        column=\"timestamp_column\"\n"
@@ -4377,7 +2421,6 @@
 #~ "        generated=\"never|always\"\n"
 #~ "        node=\"element-name|@attribute-name|element/@attribute|.\"\n"
 #~ "/>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<property\n"
 #~ "        name=\"propertyName\"\n"
@@ -5113,23 +3156,18 @@
 #~ "        &lt;column .... /&gt;\n"
 #~ "        .....\n"
 #~ "&lt;/any&gt;"
-
 #~ msgid "string"
 #~ msgstr "string"
 
 #, fuzzy
 #~ msgid "class"
 #~ msgstr "子类（subclass）"
-
 #~ msgid "binary"
 #~ msgstr "binary"
-
 #~ msgid "text"
 #~ msgstr "text"
-
 #~ msgid "serializable"
 #~ msgstr "serializable"
-
 #~ msgid "clob, blob"
 #~ msgstr "clob, blob"
 
@@ -5547,3 +3585,4 @@
 #~ "&gt;\n"
 #~ "    &lt;/database-object&gt;\n"
 #~ "&lt;/hibernate-mapping&gt;"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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:25\n"
-"PO-Revision-Date: 2009-11-23 09:45+1000\n"
+"PO-Revision-Date: 2009-12-11 09:27+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -21,62 +21,33 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A naive approach to inserting 100,000 rows in the database using Hibernate "
-"might look like this:"
-msgstr ""
-"使用 Hibernate å°† 100,000 æ¡è®°å½•æ’å…¥åˆ°æ•°æ®åº“çš„ä¸€ä¸ªå¾ˆå¤©çœŸçš„åšæ³•å¯èƒ½æ˜¯è¿™æ ·çš„ï¼š"
+msgid "A naive approach to inserting 100,000 rows in the database using Hibernate might look like this:"
+msgstr "使用 Hibernate å°† 100,000 æ¡è®°å½•æ’å…¥åˆ°æ•°æ®åº“çš„ä¸€ä¸ªå¾ˆå¤©çœŸçš„åšæ³•å¯èƒ½æ˜¯è¿™æ ·çš„ï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This would fall over with an <literal>OutOfMemoryException</literal> "
-"somewhere around the 50,000th row. That is because Hibernate caches all the "
-"newly inserted <literal>Customer</literal> instances in the session-level "
-"cache. In this chapter we will show you how to avoid this problem."
-msgstr ""
-"这段程序大概运行到 50，000 条记录左右会失败并抛出<literal>内存溢出异常"
-"（OutOfMemoryException）</literal> ã€‚è¿™æ˜¯å› ä¸º Hibernate 把所有新插入的"
-"<literal>客户（Customer）</literal>实例在 session 级别的缓存区进行了缓存的缘"
-"故。 "
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50,000th row. That is because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache. In this chapter we will show you how to avoid this problem."
+msgstr "这段程序大概运行到 50，000 条记录左右会失败并抛出<literal>内存溢出异常（OutOfMemoryException）</literal> ã€‚è¿™æ˜¯å› ä¸º Hibernate 把所有新插入的<literal>客户（Customer）</literal>实例在 session 级别的缓存区进行了缓存的缘故。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you are undertaking batch processing you will need to enable the use of "
-"JDBC batching. This is absolutely essential if you want to achieve optimal "
-"performance. Set the JDBC batch size to a reasonable number (10-50, for "
-"example):"
-msgstr ""
-"æˆ‘ä»¬ä¼šåœ¨æœ¬ç« å‘Šè¯‰ä½ å¦‚ä½•é¿å…æ­¤ç±»é—®é¢˜ã€‚é¦–å…ˆï¼Œå¦‚æžœä½ è¦æ‰§è¡Œæ‰¹é‡å¤„ç†å¹¶ä¸”æƒ³è¦è¾¾åˆ°ä¸€"
-"个理想的性能，那么使用 JDBC 的批量（batching）功能是至关重要。将 JDBC 的批量"
-"抓取数量（batch size）参数设置到一个合适值（比如，10 - 50 之间）："
+msgid "If you are undertaking batch processing you will need to enable the use of JDBC batching. This is absolutely essential if you want to achieve optimal performance. Set the JDBC batch size to a reasonable number (10-50, for example):"
+msgstr "æˆ‘ä»¬ä¼šåœ¨æœ¬ç« å‘Šè¯‰ä½ å¦‚ä½•é¿å…æ­¤ç±»é—®é¢˜ã€‚é¦–å…ˆï¼Œå¦‚æžœä½ è¦æ‰§è¡Œæ‰¹é‡å¤„ç†å¹¶ä¸”æƒ³è¦è¾¾åˆ°ä¸€ä¸ªç†æƒ³çš„æ€§èƒ½ï¼Œé‚£ä¹ˆä½¿ç”¨ JDBC 的批量（batching）功能是至关重要。将 JDBC 的批量抓取数量（batch size）参数设置到一个合适值（比如，10 - 50 之间）："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate disables insert batching at the JDBC level transparently if you "
-"use an <literal>identity</literal> identifier generator."
-msgstr ""
-"æ³¨æ„ï¼Œå‡è‹¥ä½ ä½¿ç”¨äº† <literal>identiy</literal> æ ‡è¯†ç¬¦ç”Ÿæˆå™¨ï¼ŒHibernate 在 "
-"JDBC 级别透明的关闭插入语句的批量执行。 "
+msgid "Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identity</literal> identifier generator."
+msgstr "æ³¨æ„ï¼Œå‡è‹¥ä½ ä½¿ç”¨äº† <literal>identiy</literal> æ ‡è¯†ç¬¦ç”Ÿæˆå™¨ï¼ŒHibernate 在 JDBC 级别透明的关闭插入语句的批量执行。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can also do this kind of work in a process where interaction with the "
-"second-level cache is completely disabled:"
+msgid "You can also do this kind of work in a process where interaction with the second-level cache is completely disabled:"
 msgstr "ä½ ä¹Ÿå¯èƒ½æƒ³åœ¨æ‰§è¡Œæ‰¹é‡å¤„ç†æ—¶å®Œå…¨å…³é—­äºŒçº§ç¼“å­˜ï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"However, this is not absolutely necessary, since we can explicitly set the "
-"<literal>CacheMode</literal> to disable interaction with the second-level "
-"cache."
-msgstr ""
-"ä½†æ˜¯ï¼Œè¿™ä¸æ˜¯ç»å¯¹å¿…é¡»çš„ï¼Œå› ä¸ºæˆ‘ä»¬å¯ä»¥æ˜¾å¼è®¾ç½® <literal>CacheMode</literal> 来"
-"关闭与二级缓存的交互。"
+msgid "However, this is not absolutely necessary, since we can explicitly set the <literal>CacheMode</literal> to disable interaction with the second-level cache."
+msgstr "ä½†æ˜¯ï¼Œè¿™ä¸æ˜¯ç»å¯¹å¿…é¡»çš„ï¼Œå› ä¸ºæˆ‘ä»¬å¯ä»¥æ˜¾å¼è®¾ç½® <literal>CacheMode</literal> 来关闭与二级缓存的交互。"
 
 #. Tag: title
 #, no-c-format
@@ -85,13 +56,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"When making new objects persistent <literal>flush()</literal> and then "
-"<literal>clear()</literal> the session regularly in order to control the "
-"size of the first-level cache."
-msgstr ""
-"å¦‚æžœè¦å°†å¾ˆå¤šå¯¹è±¡æŒä¹…åŒ–ï¼Œä½ å¿…é¡»é€šè¿‡ç»å¸¸çš„è°ƒç”¨ <literal>flush()</literal> 以及"
-"稍后调用  <literal>clear()</literal> 来控制第一级缓存的大小。 "
+msgid "When making new objects persistent <literal>flush()</literal> and then <literal>clear()</literal> the session regularly in order to control the size of the first-level cache."
+msgstr "å¦‚æžœè¦å°†å¾ˆå¤šå¯¹è±¡æŒä¹…åŒ–ï¼Œä½ å¿…é¡»é€šè¿‡ç»å¸¸çš„è°ƒç”¨ <literal>flush()</literal> 以及稍后调用  <literal>clear()</literal> 来控制第一级缓存的大小。 "
 
 #. Tag: title
 #, no-c-format
@@ -100,13 +66,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For retrieving and updating data, the same ideas apply. In addition, you "
-"need to use <literal>scroll()</literal> to take advantage of server-side "
-"cursors for queries that return many rows of data."
-msgstr ""
-"æ­¤æ–¹æ³•åŒæ ·é€‚ç”¨äºŽæ£€ç´¢å’Œæ›´æ–°æ•°æ®ã€‚æ­¤å¤–ï¼Œåœ¨è¿›è¡Œä¼šè¿”å›žå¾ˆå¤šè¡Œæ•°æ®çš„æŸ¥è¯¢æ—¶ï¼Œä½ éœ€è¦"
-"使用 <literal>scroll()</literal> æ–¹æ³•ä»¥ä¾¿å……åˆ†åˆ©ç”¨æœåŠ¡å™¨ç«¯æ¸¸æ ‡æ‰€å¸¦æ¥çš„å¥½å¤„ã€‚ "
+msgid "For retrieving and updating data, the same ideas apply. In addition, you need to use <literal>scroll()</literal> to take advantage of server-side cursors for queries that return many rows of data."
+msgstr "æ­¤æ–¹æ³•åŒæ ·é€‚ç”¨äºŽæ£€ç´¢å’Œæ›´æ–°æ•°æ®ã€‚æ­¤å¤–ï¼Œåœ¨è¿›è¡Œä¼šè¿”å›žå¾ˆå¤šè¡Œæ•°æ®çš„æŸ¥è¯¢æ—¶ï¼Œä½ éœ€è¦ä½¿ç”¨ <literal>scroll()</literal> æ–¹æ³•ä»¥ä¾¿å……åˆ†åˆ©ç”¨æœåŠ¡å™¨ç«¯æ¸¸æ ‡æ‰€å¸¦æ¥çš„å¥½å¤„ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -115,57 +76,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Alternatively, Hibernate provides a command-oriented API that can be used "
-"for streaming data to and from the database in the form of detached objects. "
-"A <literal>StatelessSession</literal> has no persistence context associated "
-"with it and does not provide many of the higher-level life cycle semantics. "
-"In particular, a stateless session does not implement a first-level cache "
-"nor interact with any second-level or query cache. It does not implement "
-"transactional write-behind or automatic dirty checking. Operations performed "
-"using a stateless session never cascade to associated instances. Collections "
-"are ignored by a stateless session. Operations performed via a stateless "
-"session bypass Hibernate's event model and interceptors. Due to the lack of "
-"a first-level cache, Stateless sessions are vulnerable to data aliasing "
-"effects. A stateless session is a lower-level abstraction that is much "
-"closer to the underlying JDBC."
-msgstr ""
-"作为选择，Hibernate 提供了基于命令的 API，可以用 detached object 的形式把数据"
-"ä»¥æµçš„æ–¹æ³•åŠ å…¥åˆ°æ•°æ®åº“ï¼Œæˆ–ä»Žæ•°æ®åº“è¾“å‡ºã€‚<literal>StatelessSession</literal> "
-"æ²¡æœ‰æŒä¹…åŒ–ä¸Šä¸‹æ–‡ï¼Œä¹Ÿä¸æä¾›å¤šå°‘é«˜å±‚çš„ç”Ÿå‘½å‘¨æœŸè¯­ä¹‰ã€‚ç‰¹åˆ«æ˜¯ï¼Œæ— çŠ¶æ€ session 不实"
-"现第一级 cache，也不和第二级缓存，或者查询缓存交互。它不实现事务化写，也不实"
-"现脏数据检查。用 stateless session 进行的操作甚至不级联到关联实例。stateless "
-"session 忽略集合类（Collections）。通过 stateless session 进行的操作不触发 "
-"Hibernate çš„äº‹ä»¶æ¨¡åž‹å’Œæ‹¦æˆªå™¨ã€‚æ— çŠ¶æ€ session å¯¹æ•°æ®çš„æ··æ·†çŽ°è±¡å…ç–«ï¼Œå› ä¸ºå®ƒæ²¡æœ‰"
-"ç¬¬ä¸€çº§ç¼“å­˜ã€‚æ— çŠ¶æ€ session 是低层的抽象，和低层 JDBC 相当接近。 "
+msgid "Alternatively, Hibernate provides a command-oriented API that can be used for streaming data to and from the database in the form of detached objects. A <literal>StatelessSession</literal> has no persistence context associated with it and does not provide many of the higher-level life cycle semantics. In particular, a stateless session does not implement a first-level cache nor interact with any second-level or query cache. It does not implement transactional write-behind or automatic dirty checking. Operations performed using a stateless session never cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Due to the lack of a first-level cache, Stateless sessions are vulnerable to data aliasing effects. A stateless session is a lower-level abstraction that is much closer to the underlying JDBC."
+msgstr "作为选择，Hibernate 提供了基于命令的 API，可以用 detached object çš„å½¢å¼æŠŠæ•°æ®ä»¥æµçš„æ–¹æ³•åŠ å…¥åˆ°æ•°æ®åº“ï¼Œæˆ–ä»Žæ•°æ®åº“è¾“å‡ºã€‚<literal>StatelessSession</literal> æ²¡æœ‰æŒä¹…åŒ–ä¸Šä¸‹æ–‡ï¼Œä¹Ÿä¸æä¾›å¤šå°‘é«˜å±‚çš„ç”Ÿå‘½å‘¨æœŸè¯­ä¹‰ã€‚ç‰¹åˆ«æ˜¯ï¼Œæ— çŠ¶æ€ session 不实现第一级 cache，也不和第二级缓存，或者查询缓存交互。它不实现事务化写，也不实现脏数据检查。用 stateless session 进行的操作甚至不级联到关联实例。stateless session 忽略集合类（Collections）。通过 stateless session 进行的操作不触发 Hibernate çš„äº‹ä»¶æ¨¡åž‹å’Œæ‹¦æˆªå™¨ã€‚æ— çŠ¶æ€ session å¯¹æ•°æ®çš„æ··æ·†çŽ°è±¡å…ç–«ï¼Œå› ä¸ºå®ƒæ²¡æœ‰ç¬¬ä¸€çº§ç¼“å­˜ã€‚æ— çŠ¶æ€ session 是低层的抽象，和低层 JDBC 相当接近。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In this code example, the <literal>Customer</literal> instances returned by "
-"the query are immediately detached. They are never associated with any "
-"persistence context."
-msgstr ""
-"注意在上面的例子中，查询返回的 <literal>Customer</literal> 实例立即被脱管"
-"（detach）。它们与任何持久化上下文都没有关系。 "
+msgid "In this code example, the <literal>Customer</literal> instances returned by the query are immediately detached. They are never associated with any persistence context."
+msgstr "注意在上面的例子中，查询返回的 <literal>Customer</literal> 实例立即被脱管（detach）。它们与任何持久化上下文都没有关系。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>insert(), update()</literal> and <literal>delete()</literal> "
-"operations defined by the <literal>StatelessSession</literal> interface are "
-"considered to be direct database row-level operations. They result in the "
-"immediate execution of a SQL <literal>INSERT, UPDATE</literal> or "
-"<literal>DELETE</literal> respectively. They have different semantics to the "
-"<literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> "
-"operations defined by the <literal>Session</literal> interface."
-msgstr ""
-"<literal>StatelessSession</literal> 接口定义的 <literal>insert(), update()</"
-"literal> 和 <literal>delete()</literal> 操作是直接的数据库行级别操作，其结果"
-"是立刻执行一条 <literal>INSERT, UPDATE</literal> 或 <literal>DELETE</"
-"literal> è¯­å¥ã€‚å› æ­¤ï¼Œå®ƒä»¬çš„è¯­ä¹‰å’Œ <literal>Session</literal> 接口定义的 "
-"<literal>save(), saveOrUpdate()</literal> 和<literal>delete()</literal> 操作"
-"有很大的不同。 "
+msgid "The <literal>insert(), update()</literal> and <literal>delete()</literal> operations defined by the <literal>StatelessSession</literal> interface are considered to be direct database row-level operations. They result in the immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. They have different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr "<literal>StatelessSession</literal> 接口定义的 <literal>insert(), update()</literal> å’Œ <literal>delete()</literal> 操作是直接的数据库行级别操作，其结果是立刻执行一条 <literal>INSERT, UPDATE</literal> 或 <literal>DELETE</literal> è¯­å¥ã€‚å› æ­¤ï¼Œå®ƒä»¬çš„è¯­ä¹‰å’Œ <literal>Session</literal> 接口定义的 <literal>save(), saveOrUpdate()</literal> å’Œ<literal>delete()</literal> 操作有很大的不同。 "
 
 #. Tag: title
 #, no-c-format
@@ -173,36 +95,14 @@
 msgstr "DMLï¼ˆæ•°æ®æ“ä½œè¯­è¨€ï¼‰é£Žæ ¼çš„æ“ä½œï¼ˆDML-style operations）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"As already discussed, automatic and transparent object/relational mapping is "
-"concerned with the management of the object state. The object state is "
-"available in memory. This means that manipulating data directly in the "
-"database (using the SQL <literal>Data Manipulation Language</literal> (DML) "
-"the statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, "
-"<literal>DELETE</literal>) will not affect in-memory state. However, "
-"Hibernate provides methods for bulk SQL-style DML statement execution that "
-"is performed through the Hibernate Query Language (<xref linkend=\"queryhql"
-"\" />)."
-msgstr ""
-"å°±åƒå·²ç»è®¨è®ºçš„é‚£æ ·ï¼Œè‡ªåŠ¨å’Œé€æ˜Žçš„å¯¹è±¡/å…³ç³»æ˜ å°„ï¼ˆobject/relational mapping）关"
-"æ³¨äºŽç®¡ç†å¯¹è±¡çš„çŠ¶æ€ã€‚è¿™å°±æ„å‘³ç€å¯¹è±¡çš„çŠ¶æ€å­˜åœ¨äºŽå†…å­˜ï¼Œå› æ­¤ç›´æŽ¥æ“ä½œï¼ˆä½¿ç”¨ SQL "
-"<literal>Data Manipulation Language</literal>（DML,数据操作语言）语句 ："
-"<literal>INSERT</literal> ,<literal>UPDATE</literal> 和 <literal>DELETE</"
-"literal>） 数据库中的数据将不会影响内存中的对象状态和对象数据。不过，"
-"Hibernate 提供通过 Hibernate 查询语言（<xref linkend=\"queryhql\"/>）来执行大"
-"批量 SQL é£Žæ ¼çš„ DML 语句的方法。"
+#, no-c-format
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of the object state. The object state is available in memory. This means that manipulating data directly in the database (using the SQL <literal>Data Manipulation Language</literal> (DML) the statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution that is performed through the Hibernate Query Language (<xref linkend=\"queryhql\" />)."
+msgstr "å°±åƒå·²ç»è®¨è®ºçš„é‚£æ ·ï¼Œè‡ªåŠ¨å’Œé€æ˜Žçš„å¯¹è±¡/å…³ç³»æ˜ å°„ï¼ˆobject/relational mappingï¼‰å…³æ³¨äºŽç®¡ç†å¯¹è±¡çš„çŠ¶æ€ã€‚è¿™å°±æ„å‘³ç€å¯¹è±¡çš„çŠ¶æ€å­˜åœ¨äºŽå†…å­˜ï¼Œå› æ­¤ç›´æŽ¥æ“ä½œï¼ˆä½¿ç”¨ SQL <literal>Data Manipulation Language</literal>（DML,数据操作语言）语句 ：<literal>INSERT</literal> ,<literal>UPDATE</literal> å’Œ <literal>DELETE</literal>） 数据库中的数据将不会影响内存中的对象状态和对象数据。不过，Hibernate 提供通过 Hibernate 查询语言（<xref linkend=\"queryhql\"/>）来执行大批量 SQL é£Žæ ¼çš„ DML 语句的方法。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</"
-"literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE "
-"where_conditions)?</literal>."
-msgstr ""
-"<literal>UPDATE</literal> 和 <literal>DELETE</literal> 语句的伪语法为："
-"<literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</"
-"literal>。"
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>."
+msgstr "<literal>UPDATE</literal> 和 <literal>DELETE</literal> 语句的伪语法为：<literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>。"
 
 #. Tag: para
 #, no-c-format
@@ -216,26 +116,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"There can only be a single entity named in the from-clause. It can, however, "
-"be aliased. If the entity name is aliased, then any property references must "
-"be qualified using that alias. If the entity name is not aliased, then it is "
-"illegal for any property references to be qualified."
-msgstr ""
-"在 FROM 子句（from-clause）中只能有一个实体名，它可以是别名。如果实体名是别"
-"åï¼Œé‚£ä¹ˆä»»ä½•è¢«å¼•ç”¨çš„å±žæ€§éƒ½å¿…é¡»åŠ ä¸Šæ­¤åˆ«åçš„å‰ç¼€ï¼›å¦‚æžœä¸æ˜¯åˆ«åï¼Œé‚£ä¹ˆä»»ä½•æœ‰å‰ç¼€"
-"的属性引用都是非法的。 "
+msgid "There can only be a single entity named in the from-clause. It can, however, be aliased. If the entity name is aliased, then any property references must be qualified using that alias. If the entity name is not aliased, then it is illegal for any property references to be qualified."
+msgstr "在 FROM 子句（from-clauseï¼‰ä¸­åªèƒ½æœ‰ä¸€ä¸ªå®žä½“åï¼Œå®ƒå¯ä»¥æ˜¯åˆ«åã€‚å¦‚æžœå®žä½“åæ˜¯åˆ«åï¼Œé‚£ä¹ˆä»»ä½•è¢«å¼•ç”¨çš„å±žæ€§éƒ½å¿…é¡»åŠ ä¸Šæ­¤åˆ«åçš„å‰ç¼€ï¼›å¦‚æžœä¸æ˜¯åˆ«åï¼Œé‚£ä¹ˆä»»ä½•æœ‰å‰ç¼€çš„å±žæ€§å¼•ç”¨éƒ½æ˜¯éžæ³•çš„ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"No <xref linkend=\"queryhql-joins-forms\" />, either implicit or explicit, "
-"can be specified in a bulk HQL query. Sub-queries can be used in the where-"
-"clause, where the subqueries themselves may contain joins."
-msgstr ""
-"不能在大批量 HQL 语句中使用 <xref linkend=\"queryhql-joins-forms\"/> 连接（显"
-"式或者隐式的都不行）。不过在 WHERE 子句中可以使用子查询。可以在 where 子句中"
-"使用子查询，子查询本身可以包含 join。"
+#, no-c-format
+msgid "No <xref linkend=\"queryhql-joins-forms\" />, either implicit or explicit, can be specified in a bulk HQL query. Sub-queries can be used in the where-clause, where the subqueries themselves may contain joins."
+msgstr "不能在大批量 HQL 语句中使用 <xref linkend=\"queryhql-joins-forms\"/> 连接（显式或者隐式的都不行）。不过在 WHERE 子句中可以使用子查询。可以在 where 子句中使用子查询，子查询本身可以包含 join。 "
 
 #. Tag: para
 #, no-c-format
@@ -244,181 +131,62 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"As an example, to execute an HQL <literal>UPDATE</literal>, use the "
-"<literal>Query.executeUpdate()</literal> method. The method is named for "
-"those familiar with JDBC's <literal>PreparedStatement.executeUpdate()</"
-"literal>:"
-msgstr ""
-"举个例子，使用 <literal>Query.executeUpdate()</literal> 方法执行一个 HQL "
-"<literal>UPDATE</literal>语句（方法命名是来源于 JDBC 的 "
-"<literal>PreparedStatement.executeUpdate()</literal>）： "
+msgid "As an example, to execute an HQL <literal>UPDATE</literal>, use the <literal>Query.executeUpdate()</literal> method. The method is named for those familiar with JDBC's <literal>PreparedStatement.executeUpdate()</literal>:"
+msgstr "举个例子，使用 <literal>Query.executeUpdate()</literal> 方法执行一个 HQL <literal>UPDATE</literal>语句（方法命名是来源于 JDBC 的 <literal>PreparedStatement.executeUpdate()</literal>）： "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"In keeping with the EJB3 specification, HQL <literal>UPDATE</literal> "
-"statements, by default, do not effect the <xref linkend=\"mapping-"
-"declaration-version\" /> or the <xref linkend=\"mapping-declaration-timestamp"
-"\" /> property values for the affected entities. However, you can force "
-"Hibernate to reset the <literal>version</literal> or <literal>timestamp</"
-"literal> property values through the use of a <literal>versioned update</"
-"literal>. This is achieved by adding the <literal>VERSIONED</literal> "
-"keyword after the <literal>UPDATE</literal> keyword."
-msgstr ""
-"HQL <literal>UPDATE</literal> 语句，默认不会影响更新实体的 <xref linkend="
-"\"mapping-declaration-version\"/> 或者 <xref linkend=\"mapping-declaration-"
-"timestamp\"/> 属性值。这和 EJB3 规范是一致的。但是，通过使用 "
-"<literal>versioned update</literal>ï¼Œä½ å¯ä»¥å¼ºåˆ¶ Hibernate 正确的重置"
-"<literal>version</literal> 或者 <literal>timestamp</literal> 属性值。这通过"
-"在 <literal>UPDATE</literal> å…³é”®å­—åŽé¢å¢žåŠ  <literal>VERSIONED</literal> 关键"
-"字来实现的。"
+#, no-c-format
+msgid "In keeping with the EJB3 specification, HQL <literal>UPDATE</literal> statements, by default, do not effect the <xref linkend=\"mapping-declaration-version\" /> or the <xref linkend=\"mapping-declaration-timestamp\" /> property values for the affected entities. However, you can force Hibernate to reset the <literal>version</literal> or <literal>timestamp</literal> property values through the use of a <literal>versioned update</literal>. This is achieved by adding the <literal>VERSIONED</literal> keyword after the <literal>UPDATE</literal> keyword."
+msgstr "HQL <literal>UPDATE</literal> 语句，默认不会影响更新实体的 <xref linkend=\"mapping-declaration-version\"/> 或者 <xref linkend=\"mapping-declaration-timestamp\"/> 属性值。这和 EJB3 规范是一致的。但是，通过使用 <literal>versioned update</literal>ï¼Œä½ å¯ä»¥å¼ºåˆ¶ Hibernate 正确的重置<literal>version</literal> 或者 <literal>timestamp</literal> 属性值。这通过在 <literal>UPDATE</literal> å…³é”®å­—åŽé¢å¢žåŠ  <literal>VERSIONED</literal> 关键字来实现的。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Custom version types, <literal>org.hibernate.usertype.UserVersionType</"
-"literal>, are not allowed in conjunction with a <literal>update versioned</"
-"literal> statement."
-msgstr ""
-"注意，自定义的版本类型（<literal>org.hibernate.usertype.UserVersionType</"
-"literal>）不允许和 <literal>update versioned</literal> 语句联用。 "
+msgid "Custom version types, <literal>org.hibernate.usertype.UserVersionType</literal>, are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr "注意，自定义的版本类型（<literal>org.hibernate.usertype.UserVersionType</literal>）不允许和 <literal>update versioned</literal> 语句联用。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"To execute an HQL <literal>DELETE</literal>, use the same <literal>Query."
-"executeUpdate()</literal> method:"
-msgstr ""
-"执行一个 HQL <literal>DELETE</literal>ï¼ŒåŒæ ·ä½¿ç”¨ <literal>Query.executeUpdate"
-"()</literal> 方法："
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr "执行一个 HQL <literal>DELETE</literal>ï¼ŒåŒæ ·ä½¿ç”¨ <literal>Query.executeUpdate()</literal> 方法："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>int</literal> value returned by the <literal>Query.executeUpdate"
-"()</literal> method indicates the number of entities effected by the "
-"operation. This may or may not correlate to the number of rows effected in "
-"the database. An HQL bulk operation might result in multiple actual SQL "
-"statements being executed (for joined-subclass, for example). The returned "
-"number indicates the number of actual entities affected by the statement. "
-"Going back to the example of joined-subclass, a delete against one of the "
-"subclasses may actually result in deletes against not just the table to "
-"which that subclass is mapped, but also the \"root\" table and potentially "
-"joined-subclass tables further down the inheritance hierarchy."
-msgstr ""
-"由 <literal>Query.executeUpdate()</literal> 方法返回的<literal>整型</literal>"
-"值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条 SQL 语"
-"句）影响了的“行”数有关，也可能没有。一个大批量 HQL 操作可能导致多条实际的SQL"
-"语句被执行，举个例子，对 joined-subclass æ˜ å°„æ–¹å¼çš„ç±»è¿›è¡Œçš„æ­¤ç±»æ“ä½œã€‚è¿™ä¸ªè¿”å›ž"
-"值代表了实际被语句影响了的记录数量。在那个 joined-subclass 的例子中， 对一个"
-"å­ç±»çš„åˆ é™¤å®žé™…ä¸Šå¯èƒ½ä¸ä»…ä»…ä¼šåˆ é™¤å­ç±»æ˜ å°„åˆ°çš„è¡¨è€Œä¸”ä¼šå½±å“â€œæ ¹â€è¡¨ï¼Œè¿˜æœ‰å¯èƒ½å½±å“"
-"与之有继承关系的 joined-subclass æ˜ å°„æ–¹å¼çš„å­ç±»çš„è¡¨ã€‚ "
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicates the number of entities effected by the operation. This may or may not correlate to the number of rows effected in the database. An HQL bulk operation might result in multiple actual SQL statements being executed (for joined-subclass, for example). The returned number indicates the number of actual entities affected by the statement. Going back to the example of joined-subclass, a delete against one of the subclasses may actually result in deletes against not just the table to which that subclass is mapped, but also the \"root\" table and potentially joined-subclass tables further down the inheritance hierarchy."
+msgstr "ç”± <literal>Query.executeUpdate()</literal> 方法返回的<literal>æ•´åž‹</literal>值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条 SQL 语句）影响了的“行”数有关，也可能没有。一个大批量 HQL 操作可能导致多条实际的SQL语句被执行，举个例子，对 joined-subclass æ˜ å°„æ–¹å¼çš„ç±»è¿›è¡Œçš„æ­¤ç±»æ“ä½œã€‚è¿™ä¸ªè¿”å›žå€¼ä»£è¡¨äº†å®žé™…è¢«è¯­å¥å½±å“äº†çš„è®°å½•æ•°é‡ã€‚åœ¨é‚£ä¸ª joined-subclass 的例子中， å¯¹ä¸€ä¸ªå­ç±»çš„åˆ é™¤å®žé™…ä¸Šå¯èƒ½ä¸ä»…ä»…ä¼šåˆ é™¤å­ç±»æ˜ å°„åˆ°çš„è¡¨è€Œä¸”ä¼šå½±å“â€œæ ¹â€è¡¨ï¼Œè¿˜æœ‰å¯èƒ½å½±å“ä¸Žä¹‹æœ‰ç»§æ‰¿å…³ç³»çš„ joined-subclass æ˜ å°„æ–¹å¼çš„å­ç±»çš„è¡¨ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The pseudo-syntax for <literal>INSERT</literal> statements is: "
-"<literal>INSERT INTO EntityName properties_list select_statement</literal>. "
-"Some points to note:"
-msgstr ""
-"<literal>INSERT</literal> è¯­å¥çš„ä¼ªç æ˜¯ï¼š<literal>INSERT INTO EntityName "
-"properties_list select_statement</literal>。要注意的是："
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr "<literal>INSERT</literal> è¯­å¥çš„ä¼ªç æ˜¯ï¼š<literal>INSERT INTO EntityName properties_list select_statement</literal>。要注意的是："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Only the INSERT INTO ... SELECT ... form is supported; not the INSERT "
-"INTO ... VALUES ... form."
-msgstr ""
-"只支持 INSERT INTO ... SELECT ... 形式，不支持 INSERT INTO ... VALUES ... 形"
-"式。"
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr "只支持 INSERT INTO ... SELECT ... 形式，不支持 INSERT INTO ... VALUES ... 形式。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The properties_list is analogous to the <literal>column specification</"
-"literal> in the SQL <literal>INSERT</literal> statement. For entities "
-"involved in mapped inheritance, only properties directly defined on that "
-"given class-level can be used in the properties_list. Superclass properties "
-"are not allowed and subclass properties do not make sense. In other words, "
-"<literal>INSERT</literal> statements are inherently non-polymorphic."
-msgstr ""
-"properties_list 和 SQL <literal>INSERT</literal> 语句中的<literal>字段定义"
-"（column speficiation）</literal>ç±»ä¼¼ã€‚å¯¹å‚ä¸Žç»§æ‰¿æ ‘æ˜ å°„çš„å®žä½“è€Œè¨€ï¼Œåªæœ‰ç›´æŽ¥å®š"
-"义在给定的类级别的属性才能直接在 properties_list 中使用。超类的属性不被支持；"
-"å­ç±»çš„å±žæ€§æ— æ„ä¹‰ã€‚æ¢å¥è¯è¯´ï¼Œ<literal>INSERT</literal> 天生不支持多态性。"
+msgid "The properties_list is analogous to the <literal>column specification</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritance, only properties directly defined on that given class-level can be used in the properties_list. Superclass properties are not allowed and subclass properties do not make sense. In other words, <literal>INSERT</literal> statements are inherently non-polymorphic."
+msgstr "properties_list å’Œ SQL <literal>INSERT</literal> 语句中的<literal>字段定义（column speficiation）</literal>ç±»ä¼¼ã€‚å¯¹å‚ä¸Žç»§æ‰¿æ ‘æ˜ å°„çš„å®žä½“è€Œè¨€ï¼Œåªæœ‰ç›´æŽ¥å®šä¹‰åœ¨ç»™å®šçš„ç±»çº§åˆ«çš„å±žæ€§æ‰èƒ½ç›´æŽ¥åœ¨ properties_list ä¸­ä½¿ç”¨ã€‚è¶…ç±»çš„å±žæ€§ä¸è¢«æ”¯æŒï¼›å­ç±»çš„å±žæ€§æ— æ„ä¹‰ã€‚æ¢å¥è¯è¯´ï¼Œ<literal>INSERT</literal> 天生不支持多态性。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"select_statement can be any valid HQL select query, with the caveat that the "
-"return types must match the types expected by the insert. Currently, this is "
-"checked during query compilation rather than allowing the check to relegate "
-"to the database. This might, however, cause problems between Hibernate "
-"<literal>Type</literal>s which are <emphasis>equivalent</emphasis> as "
-"opposed to <emphasis>equal</emphasis>. This might cause issues with "
-"mismatches between a property defined as a <literal>org.hibernate.type."
-"DateType</literal> and a property defined as a <literal>org.hibernate.type."
-"TimestampType</literal>, even though the database might not make a "
-"distinction or might be able to handle the conversion."
-msgstr ""
-"select_statement 可以是任何合法的 HQL 选择查询，不过要保证返回类型必须和要插"
-"入的类型完全匹配。目前，这一检查是在查询编译的时候进行的，而不是把它交给数据"
-"库。注意，在Hibernate<literal>Type</literal> 间如果只是<emphasis>等价"
-"（equivalent）</emphasis>而非<emphasis>相等（equal）</emphasis>，会导致问题。"
-"定义为 <literal>org.hibernate.type.DateType</literal> 和 <literal>org."
-"hibernate.type.TimestampType</literal> 的两个属性可能会产生类型不匹配错误，虽"
-"ç„¶æ•°æ®åº“çº§å¯èƒ½ä¸åŠ åŒºåˆ†æˆ–è€…å¯ä»¥å¤„ç†è¿™ç§è½¬æ¢ã€‚ "
+msgid "select_statement can be any valid HQL select query, with the caveat that the return types must match the types expected by the insert. Currently, this is checked during query compilation rather than allowing the check to relegate to the database. This might, however, cause problems between Hibernate <literal>Type</literal>s which are <emphasis>equivalent</emphasis> as opposed to <emphasis>equal</emphasis>. This might cause issues with mismatches between a property defined as a <literal>org.hibernate.type.DateType</literal> and a property defined as a <literal>org.hibernate.type.TimestampType</literal>, even though the database might not make a distinction or might be able to handle the conversion."
+msgstr "select_statement 可以是任何合法的 HQL 选择查询，不过要保证返回类型必须和要插入的类型完全匹配。目前，这一检查是在查询编译的时候进行的，而不是把它交给数据库。注意，在Hibernate<literal>Type</literal> 间如果只是<emphasis>等价（equivalent）</emphasis>而非<emphasis>相等（equal）</emphasis>，会导致问题。定义为 <literal>org.hibernate.type.DateType</literal> å’Œ <literal>org.hibernate.type.TimestampType</literal> çš„ä¸¤ä¸ªå±žæ€§å¯èƒ½ä¼šäº§ç”Ÿç±»åž‹ä¸åŒ¹é…é”™è¯¯ï¼Œè™½ç„¶æ•°æ®åº“çº§å¯èƒ½ä¸åŠ åŒºåˆ†æˆ–è€…å¯ä»¥å¤„ç†è¿™ç§è½¬æ¢ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For the id property, the insert statement gives you two options. You can "
-"either explicitly specify the id property in the properties_list, in which "
-"case its value is taken from the corresponding select expression, or omit it "
-"from the properties_list, in which case a generated value is used. This "
-"latter option is only available when using id generators that operate in the "
-"database; attempting to use this option with any \"in memory\" type "
-"generators will cause an exception during parsing. For the purposes of this "
-"discussion, in-database generators are considered to be <literal>org."
-"hibernate.id.SequenceGenerator</literal> (and its subclasses) and any "
-"implementers of <literal>org.hibernate.id.PostInsertIdentifierGenerator</"
-"literal>. The most notable exception here is <literal>org.hibernate.id."
-"TableHiLoGenerator</literal>, which cannot be used because it does not "
-"expose a selectable way to get its values."
-msgstr ""
-"对 id 属性来说，insert è¯­å¥ç»™ä½ ä¸¤ä¸ªé€‰æ‹©ã€‚ä½ å¯ä»¥æ˜Žç¡®åœ°åœ¨ properties_list 表中"
-"指定 id å±žæ€§ï¼ˆè¿™æ ·å®ƒçš„å€¼æ˜¯ä»Žå¯¹åº”çš„ select 表达式中获得），或者在 "
-"properties_list 中省略它（此时使用生成指）。后一种选择只有当使用在数据库中生"
-"成值的 id 产生器时才能使用；如果是“内存”中计算的类型生成器，在解析时会抛出一"
-"个异常。注意，为了说明这一问题，数据库产生值的生成器是 <literal>org."
-"hibernate.id.SequenceGenerator</literal>（和它的子类），以及任何 "
-"<literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> 接口的实"
-"现。这儿最值得注意的意外是 <literal>org.hibernate.id.TableHiLoGenerator</"
-"literal>ï¼Œå®ƒä¸èƒ½åœ¨æ­¤ä½¿ç”¨ï¼Œå› ä¸ºå®ƒæ²¡æœ‰å¾—åˆ°å…¶å€¼çš„é€”å¾„ã€‚ "
+msgid "For the id property, the insert statement gives you two options. You can either explicitly specify the id property in the properties_list, in which case its value is taken from the corresponding select expression, or omit it from the properties_list, in which case a generated value is used. This latter option is only available when using id generators that operate in the database; attempting to use this option with any \"in memory\" type generators will cause an exception during parsing. For the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementers of <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal>. The most notable exception here is <literal>org.hibernate.id.TableHiLoGenerator</literal>, which cannot be used because it does not expose a selectable way to get its values."
+msgstr "对 id 属性来说，insert è¯­å¥ç»™ä½ ä¸¤ä¸ªé€‰æ‹©ã€‚ä½ å¯ä»¥æ˜Žç¡®åœ°åœ¨ properties_list 表中指定 id å±žæ€§ï¼ˆè¿™æ ·å®ƒçš„å€¼æ˜¯ä»Žå¯¹åº”çš„ select 表达式中获得），或者在 properties_list 中省略它（此时使用生成指）。后一种选择只有当使用在数据库中生成值的 id 产生器时才能使用；如果是“内存”中计算的类型生成器，在解析时会抛出一个异常。注意，为了说明这一问题，数据库产生值的生成器是 <literal>org.hibernate.id.SequenceGenerator</literal>（和它的子类），以及任何 <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> 接口的实现。这儿最值得注意的意外是 <literal>org.hibernate.id.TableHiLoGenerator</literal>ï¼Œå®ƒä¸èƒ½åœ¨æ­¤ä½¿ç”¨ï¼Œå› ä¸ºå®ƒæ²¡æœ‰å¾—åˆ°å…¶å€¼çš„é€”å¾„ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For properties mapped as either <literal>version</literal> or "
-"<literal>timestamp</literal>, the insert statement gives you two options. "
-"You can either specify the property in the properties_list, in which case "
-"its value is taken from the corresponding select expressions, or omit it "
-"from the properties_list, in which case the <literal>seed value</literal> "
-"defined by the <literal>org.hibernate.type.VersionType</literal> is used."
-msgstr ""
-"å¯¹æ˜ å°„ä¸º <literal>version</literal> 或 <literal>timestamp</literal> 的属性来"
-"说，insert è¯­å¥ä¹Ÿç»™ä½ ä¸¤ä¸ªé€‰æ‹©ï¼Œä½ å¯ä»¥åœ¨ properties_list 表中指定（此时其值从"
-"对应的 select 表达式中获得），或者在 properties_list 中省略它（此时，使用在 "
-"<literal>org.hibernate.type.VersionType</literal> 中定义的 <literal>seed "
-"value（种子值）</literal>）。"
+msgid "For properties mapped as either <literal>version</literal> or <literal>timestamp</literal>, the insert statement gives you two options. You can either specify the property in the properties_list, in which case its value is taken from the corresponding select expressions, or omit it from the properties_list, in which case the <literal>seed value</literal> defined by the <literal>org.hibernate.type.VersionType</literal> is used."
+msgstr "å¯¹æ˜ å°„ä¸º <literal>version</literal> 或 <literal>timestamp</literal> 的属性来说，insert è¯­å¥ä¹Ÿç»™ä½ ä¸¤ä¸ªé€‰æ‹©ï¼Œä½ å¯ä»¥åœ¨ properties_list 表中指定（此时其值从对应的 select 表达式中获得），或者在 properties_list 中省略它（此时，使用在 <literal>org.hibernate.type.VersionType</literal> 中定义的 <literal>seed value（种子值）</literal>）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The following is an example of an HQL <literal>INSERT</literal> statement "
-"execution:"
+msgid "The following is an example of an HQL <literal>INSERT</literal> statement execution:"
 msgstr "下面是一个执行 HQL <literal>INSERT</literal> 语句的例子："
 
 #~ msgid ""
@@ -439,13 +207,10 @@
 #~ "}\n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
 #~ msgstr "<![CDATA[hibernate.jdbc.batch_size 20]]>"
-
 #~ msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
 #~ msgstr "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessionFactory.openSession();\n"
 #~ "Transaction tx = session.beginTransaction();\n"
@@ -478,7 +243,6 @@
 #~ "   \n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessionFactory.openSession();\n"
 #~ "Transaction tx = session.beginTransaction();\n"
@@ -519,7 +283,6 @@
 #~ "   \n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[StatelessSession session = sessionFactory.openStatelessSession"
 #~ "();\n"
@@ -550,7 +313,6 @@
 #~ "   \n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessionFactory.openSession();\n"
 #~ "Transaction tx = session.beginTransaction();\n"
@@ -579,7 +341,6 @@
 #~ "        .executeUpdate();\n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessionFactory.openSession();\n"
 #~ "Transaction tx = session.beginTransaction();\n"
@@ -602,7 +363,6 @@
 #~ "        .executeUpdate();\n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessionFactory.openSession();\n"
 #~ "Transaction tx = session.beginTransaction();\n"
@@ -625,7 +385,6 @@
 #~ "        .executeUpdate();\n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessionFactory.openSession();\n"
 #~ "Transaction tx = session.beginTransaction();\n"
@@ -646,3 +405,4 @@
 #~ "        .executeUpdate();\n"
 #~ "tx.commit();\n"
 #~ "session.close();]]>"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/component_mapping.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/component_mapping.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/component_mapping.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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: 2009-11-23 11:08+1000\n"
+"PO-Revision-Date: 2009-12-11 09:28+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -21,12 +21,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The notion of a <emphasis>component</emphasis> is re-used in several "
-"different contexts and purposes throughout Hibernate."
-msgstr ""
-"<emphasis>组件（Component）</emphasis>这个概念在 Hibernate ä¸­å‡ å¤„ä¸åŒçš„åœ°æ–¹ä¸º"
-"了不同的目的被重复使用。"
+msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts and purposes throughout Hibernate."
+msgstr "<emphasis>组件（Component）</emphasis>这个概念在 Hibernate ä¸­å‡ å¤„ä¸åŒçš„åœ°æ–¹ä¸ºäº†ä¸åŒçš„ç›®çš„è¢«é‡å¤ä½¿ç”¨ã€‚"
 
 #. Tag: title
 #, no-c-format
@@ -35,29 +31,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A component is a contained object that is persisted as a value type and not "
-"an entity reference. The term \"component\" refers to the object-oriented "
-"notion of composition and not to architecture-level components. For example, "
-"you can model a person like this:"
-msgstr ""
-"组件（Component）是一个被包含的对象，在持久化的过程中，它被当作值类型，而并非"
-"一个实体的引用。在这篇文档中，组件这一术语指的是面向对象的合成概念（而并不是"
-"ç³»ç»Ÿæž„æž¶å±‚æ¬¡ä¸Šçš„ç»„ä»¶çš„æ¦‚å¿µï¼‰ã€‚ä¸¾ä¸ªä¾‹å­ï¼Œä½ å¯¹äººï¼ˆPerson）这个概念可以像下面这"
-"æ ·æ¥å»ºæ¨¡ï¼š "
+msgid "A component is a contained object that is persisted as a value type and not an entity reference. The term \"component\" refers to the object-oriented notion of composition and not to architecture-level components. For example, you can model a person like this:"
+msgstr "组件（Componentï¼‰æ˜¯ä¸€ä¸ªè¢«åŒ…å«çš„å¯¹è±¡ï¼Œåœ¨æŒä¹…åŒ–çš„è¿‡ç¨‹ä¸­ï¼Œå®ƒè¢«å½“ä½œå€¼ç±»åž‹ï¼Œè€Œå¹¶éžä¸€ä¸ªå®žä½“çš„å¼•ç”¨ã€‚åœ¨è¿™ç¯‡æ–‡æ¡£ä¸­ï¼Œç»„ä»¶è¿™ä¸€æœ¯è¯­æŒ‡çš„æ˜¯é¢å‘å¯¹è±¡çš„åˆæˆæ¦‚å¿µï¼ˆè€Œå¹¶ä¸æ˜¯ç³»ç»Ÿæž„æž¶å±‚æ¬¡ä¸Šçš„ç»„ä»¶çš„æ¦‚å¿µï¼‰ã€‚ä¸¾ä¸ªä¾‹å­ï¼Œä½ å¯¹äººï¼ˆPersonï¼‰è¿™ä¸ªæ¦‚å¿µå¯ä»¥åƒä¸‹é¢è¿™æ ·æ¥å»ºæ¨¡ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Now <literal>Name</literal> can be persisted as a component of "
-"<literal>Person</literal>. <literal>Name</literal> defines getter and setter "
-"methods for its persistent properties, but it does not need to declare any "
-"interfaces or identifier properties."
-msgstr ""
-"在持久化的过程中，<literal>姓名（Name）</literal>可以作为<literal>人"
-"（Person）</literal>çš„ä¸€ä¸ªç»„ä»¶ã€‚éœ€è¦æ³¨æ„çš„æ˜¯ï¼šä½ åº”è¯¥ä¸º<literal>姓名</literal>"
-"的持久化属性定义 getter å’Œ setter æ–¹æ³•ï¼Œä½†æ˜¯ä½ ä¸éœ€è¦å®žçŽ°ä»»ä½•çš„æŽ¥å£æˆ–ç”³æ˜Žæ ‡è¯†"
-"符字段。  "
+msgid "Now <literal>Name</literal> can be persisted as a component of <literal>Person</literal>. <literal>Name</literal> defines getter and setter methods for its persistent properties, but it does not need to declare any interfaces or identifier properties."
+msgstr "在持久化的过程中，<literal>姓名（Name）</literal>可以作为<literal>人（Person）</literal>çš„ä¸€ä¸ªç»„ä»¶ã€‚éœ€è¦æ³¨æ„çš„æ˜¯ï¼šä½ åº”è¯¥ä¸º<literal>姓名</literal>的持久化属性定义 getter å’Œ setter æ–¹æ³•ï¼Œä½†æ˜¯ä½ ä¸éœ€è¦å®žçŽ°ä»»ä½•çš„æŽ¥å£æˆ–ç”³æ˜Žæ ‡è¯†ç¬¦å­—æ®µã€‚  "
 
 #. Tag: para
 #, no-c-format
@@ -66,54 +46,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The person table would have the columns <literal>pid</literal>, "
-"<literal>birthday</literal>, <literal>initial</literal>, <literal>first</"
-"literal> and <literal>last</literal>."
-msgstr ""
-"人员（Person）表中将包括 <literal>pid</literal>，<literal>birthday</"
-"literal>，<literal>initial</literal>，<literal>first</literal>和 "
-"<literal>last</literal> 等字段。"
+msgid "The person table would have the columns <literal>pid</literal>, <literal>birthday</literal>, <literal>initial</literal>, <literal>first</literal> and <literal>last</literal>."
+msgstr "人员（Person）表中将包括 <literal>pid</literal>，<literal>birthday</literal>，<literal>initial</literal>，<literal>first</literal>和 <literal>last</literal> 等字段。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Like value types, components do not support shared references. In other "
-"words, two persons could have the same name, but the two person objects "
-"would contain two independent name objects that were only \"the same\" by "
-"value. The null value semantics of a component are <emphasis>ad hoc</"
-"emphasis>. When reloading the containing object, Hibernate will assume that "
-"if all component columns are null, then the entire component is null. This "
-"is suitable for most purposes."
-msgstr ""
-"å°±åƒæ‰€æœ‰çš„å€¼ç±»åž‹ä¸€æ ·ï¼Œç»„ä»¶ä¸æ”¯æŒå…±äº«å¼•ç”¨ã€‚æ¢å¥è¯è¯´ï¼Œä¸¤ä¸ªäººå¯èƒ½é‡åï¼Œä½†æ˜¯ä¸¤ä¸ª "
-"Person 对象应该包含两个独立的 Name 对象，只不过这两个 Name å¯¹è±¡å…·æœ‰â€œåŒæ ·â€çš„"
-"值。组件的值可以为空，其定义如下。 每当 Hibernate é‡æ–°åŠ è½½ä¸€ä¸ªåŒ…å«ç»„ä»¶çš„å¯¹"
-"象，如果该组件的所有字段为空，Hibernate 将假定整个组件为空。在大多数情况下，"
-"è¿™æ ·å‡å®šåº”è¯¥æ˜¯æ²¡æœ‰é—®é¢˜çš„ã€‚"
+msgid "Like value types, components do not support shared references. In other words, two persons could have the same name, but the two person objects would contain two independent name objects that were only \"the same\" by value. The null value semantics of a component are <emphasis>ad hoc</emphasis>. When reloading the containing object, Hibernate will assume that if all component columns are null, then the entire component is null. This is suitable for most purposes."
+msgstr "å°±åƒæ‰€æœ‰çš„å€¼ç±»åž‹ä¸€æ ·ï¼Œç»„ä»¶ä¸æ”¯æŒå…±äº«å¼•ç”¨ã€‚æ¢å¥è¯è¯´ï¼Œä¸¤ä¸ªäººå¯èƒ½é‡åï¼Œä½†æ˜¯ä¸¤ä¸ª Person 对象应该包含两个独立的 Name 对象，只不过这两个 Name å¯¹è±¡å…·æœ‰â€œåŒæ ·â€çš„å€¼ã€‚ç»„ä»¶çš„å€¼å¯ä»¥ä¸ºç©ºï¼Œå…¶å®šä¹‰å¦‚ä¸‹ã€‚ 每当 Hibernate é‡æ–°åŠ è½½ä¸€ä¸ªåŒ…å«ç»„ä»¶çš„å¯¹è±¡ï¼Œå¦‚æžœè¯¥ç»„ä»¶çš„æ‰€æœ‰å­—æ®µä¸ºç©ºï¼ŒHibernate å°†å‡å®šæ•´ä¸ªç»„ä»¶ä¸ºç©ºã€‚åœ¨å¤§å¤šæ•°æƒ…å†µä¸‹ï¼Œè¿™æ ·å‡å®šåº”è¯¥æ˜¯æ²¡æœ‰é—®é¢˜çš„ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The properties of a component can be of any Hibernate type (collections, "
-"many-to-one associations, other components, etc). Nested components should "
-"<emphasis>not</emphasis> be considered an exotic usage. Hibernate is "
-"intended to support a fine-grained object model."
-msgstr ""
-"组件的属性可以是任意一种 Hibernate 类型（包括集合，多对多关联，以及其它组件等"
-"等）。嵌套组件不应该被当作一种特殊的应用（Nested components should not be "
-"considered an exotic usage）。Hibernate 倾向于支持细颗粒度的（fine-grained）"
-"对象模型。"
+msgid "The properties of a component can be of any Hibernate type (collections, many-to-one associations, other components, etc). Nested components should <emphasis>not</emphasis> be considered an exotic usage. Hibernate is intended to support a fine-grained object model."
+msgstr "组件的属性可以是任意一种 Hibernate 类型（包括集合，多对多关联，以及其它组件等等）。嵌套组件不应该被当作一种特殊的应用（Nested components should not be considered an exotic usage）。Hibernate 倾向于支持细颗粒度的（fine-grained）对象模型。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;"
-"parent&gt;</literal> subelement that maps a property of the component class "
-"as a reference back to the containing entity."
-msgstr ""
-"<literal>&lt;component&gt;</literal> å…ƒç´ å…è®¸åŠ å…¥ä¸€ä¸ª <literal>&lt;parent&gt;"
-"</literal> å­å…ƒç´ ï¼Œåœ¨ç»„ä»¶ç±»å†…éƒ¨å°±å¯ä»¥æœ‰ä¸€ä¸ªæŒ‡å‘å…¶å®¹å™¨çš„å®žä½“çš„åå‘å¼•ç”¨ã€‚"
+msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity."
+msgstr "<literal>&lt;component&gt;</literal> å…ƒç´ å…è®¸åŠ å…¥ä¸€ä¸ª <literal>&lt;parent&gt;</literal> å­å…ƒç´ ï¼Œåœ¨ç»„ä»¶ç±»å†…éƒ¨å°±å¯ä»¥æœ‰ä¸€ä¸ªæŒ‡å‘å…¶å®¹å™¨çš„å®žä½“çš„åå‘å¼•ç”¨ã€‚"
 
 #. Tag: title
 #, no-c-format
@@ -121,94 +70,34 @@
 msgstr "在集合中出现的依赖对象（Collections of dependent objects）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Collections of components are supported (e.g. an array of type "
-"<literal>Name</literal>). Declare your component collection by replacing the "
-"<literal>&lt;element&gt;</literal> tag with a <literal>&lt;composite-"
-"element&gt;</literal> tag:"
-msgstr ""
-"Hibernate æ”¯æŒç»„ä»¶çš„é›†åˆï¼ˆä¾‹å¦‚ï¼šä¸€ä¸ªå…ƒç´ æ˜¯å§“åï¼ˆNameï¼‰è¿™ç§ç±»åž‹çš„æ•°ç»„ï¼‰ã€‚ä½ å¯"
-"以使用 <literal>&lt;composite-element&gt;</literal> æ ‡ç­¾æ›¿ä»£ <literal>&lt;"
-"element&gt;</literal> æ ‡ç­¾æ¥å®šä¹‰ä½ çš„ç»„ä»¶é›†åˆã€‚"
+#, no-c-format
+msgid "Collections of components are supported (e.g. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</literal> tag:"
+msgstr "Hibernate æ”¯æŒç»„ä»¶çš„é›†åˆï¼ˆä¾‹å¦‚ï¼šä¸€ä¸ªå…ƒç´ æ˜¯å§“åï¼ˆNameï¼‰è¿™ç§ç±»åž‹çš„æ•°ç»„ï¼‰ã€‚ä½ å¯ä»¥ä½¿ç”¨ <literal>&lt;composite-element&gt;</literal> æ ‡ç­¾æ›¿ä»£ <literal>&lt;element&gt;</literal> æ ‡ç­¾æ¥å®šä¹‰ä½ çš„ç»„ä»¶é›†åˆï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you define a <literal>Set</literal> of composite elements, it is "
-"important to implement <literal>equals()</literal> and <literal>hashCode()</"
-"literal> correctly."
-msgstr ""
-"æ³¨æ„ï¼Œå¦‚æžœä½ å®šä¹‰çš„ Set åŒ…å«ç»„åˆå…ƒç´ ï¼ˆcomposite-element），正确地实现 "
-"<literal>equals()</literal> 和 <literal>hashCode()</literal> 是非常重要的。 "
+msgid "If you define a <literal>Set</literal> of composite elements, it is important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
+msgstr "æ³¨æ„ï¼Œå¦‚æžœä½ å®šä¹‰çš„ Set åŒ…å«ç»„åˆå…ƒç´ ï¼ˆcomposite-element），正确地实现 <literal>equals()</literal> å’Œ <literal>hashCode()</literal> 是非常重要的。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Composite elements can contain components but not collections. If your "
-"composite element contains components, use the <literal>&lt;nested-composite-"
-"element&gt;</literal> tag. This case is a collection of components which "
-"themselves have components. You may want to consider if a one-to-many "
-"association is more appropriate. Remodel the composite element as an entity, "
-"but be aware that even though the Java model is the same, the relational "
-"model and persistence semantics are still slightly different."
-msgstr ""
-"ç»„åˆå…ƒç´ å¯ä»¥åŒ…å«ç»„ä»¶ï¼Œä½†æ˜¯ä¸èƒ½åŒ…å«é›†åˆã€‚å¦‚æžœä½ çš„ç»„åˆå…ƒç´ è‡ªèº«åŒ…å«ç»„ä»¶ï¼Œä½ å¿…é¡»"
-"使用 <literal>&lt;nested-composite-element&gt;</literal> æ ‡ç­¾ã€‚è¿™æ˜¯ä¸€ä¸ªç›¸å½“ç‰¹"
-"殊的案例 — åœ¨ä¸€ä¸ªç»„ä»¶çš„é›†åˆé‡Œï¼Œé‚£äº›ç»„ä»¶æœ¬èº«åˆå¯ä»¥åŒ…å«å…¶ä»–çš„ç»„ä»¶ã€‚è¿™ä¸ªæ—¶å€™ä½ å°±"
-"应该考虑一下使用 one-to-many å…³è”æ˜¯å¦ä¼šæ›´æ°å½“ã€‚å°è¯•å¯¹è¿™ä¸ªç»„åˆå…ƒç´ é‡æ–°å»ºæ¨¡ä¸ºä¸€"
-"个实体 — 但是需要注意的是，虽然 Java æ¨¡åž‹å’Œé‡æ–°å»ºæ¨¡å‰æ˜¯ä¸€æ ·çš„ï¼Œå…³ç³»æ¨¡åž‹å’ŒæŒä¹…"
-"性语义会有细微的变化。"
+#, no-c-format
+msgid "Composite elements can contain components but not collections. If your composite element contains components, use the <literal>&lt;nested-composite-element&gt;</literal> tag. This case is a collection of components which themselves have components. You may want to consider if a one-to-many association is more appropriate. Remodel the composite element as an entity, but be aware that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
+msgstr "ç»„åˆå…ƒç´ å¯ä»¥åŒ…å«ç»„ä»¶ï¼Œä½†æ˜¯ä¸èƒ½åŒ…å«é›†åˆã€‚å¦‚æžœä½ çš„ç»„åˆå…ƒç´ è‡ªèº«åŒ…å«ç»„ä»¶ï¼Œä½ å¿…é¡»ä½¿ç”¨ <literal>&lt;nested-composite-element&gt;</literal> æ ‡ç­¾ã€‚è¿™æ˜¯ä¸€ä¸ªç›¸å½“ç‰¹æ®Šçš„æ¡ˆä¾‹ — åœ¨ä¸€ä¸ªç»„ä»¶çš„é›†åˆé‡Œï¼Œé‚£äº›ç»„ä»¶æœ¬èº«åˆå¯ä»¥åŒ…å«å…¶ä»–çš„ç»„ä»¶ã€‚è¿™ä¸ªæ—¶å€™ä½ å°±åº”è¯¥è€ƒè™‘ä¸€ä¸‹ä½¿ç”¨ one-to-many å…³è”æ˜¯å¦ä¼šæ›´æ°å½“ã€‚å°è¯•å¯¹è¿™ä¸ªç»„åˆå…ƒç´ é‡æ–°å»ºæ¨¡ä¸ºä¸€ä¸ªå®žä½“ — 但是需要注意的是，虽然 Java æ¨¡åž‹å’Œé‡æ–°å»ºæ¨¡å‰æ˜¯ä¸€æ ·çš„ï¼Œå…³ç³»æ¨¡åž‹å’ŒæŒä¹…æ€§è¯­ä¹‰ä¼šæœ‰ç»†å¾®çš„å˜åŒ–ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A composite element mapping does not support null-able properties if you are "
-"using a <literal>&lt;set&gt;</literal>. There is no separate primary key "
-"column in the composite element table. Hibernate uses each column's value to "
-"identify a record when deleting objects, which is not possible with null "
-"values. You have to either use only not-null properties in a composite-"
-"element or choose a <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</"
-"literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>."
-msgstr ""
-"è¯·æ³¨æ„å¦‚æžœä½ ä½¿ç”¨ <literal>&lt;set&gt;</literal> æ ‡ç­¾ï¼Œä¸€ä¸ªç»„åˆå…ƒç´ çš„æ˜ å°„ä¸æ”¯"
-"持可能为空的属性. å½“åˆ é™¤å¯¹è±¡æ—¶ï¼ŒHibernate 必须使用每一个字段的值来确定一条记"
-"å½•ï¼ˆåœ¨ç»„åˆå…ƒç´ è¡¨ä¸­ï¼Œæ²¡æœ‰å•ç‹¬çš„å…³é”®å­—æ®µï¼‰ï¼Œå¦‚æžœæœ‰ä¸º null çš„å­—æ®µï¼Œè¿™æ ·åšå°±ä¸å¯"
-"èƒ½äº†ã€‚ä½ å¿…é¡»ä½œå‡ºä¸€ä¸ªé€‰æ‹©ï¼Œè¦ä¹ˆåœ¨ç»„åˆå…ƒç´ ä¸­ä½¿ç”¨ä¸èƒ½ä¸ºç©ºçš„å±žæ€§ï¼Œè¦ä¹ˆé€‰æ‹©ä½¿ç”¨ "
-"<literal>&lt;list&gt;</literal>，<literal>&lt;map&gt;</literal>，"
-"<literal>&lt;bag&gt;</literal> 或者 <literal>&lt;idbag&gt;</literal> 而不是 "
-"<literal>&lt;set&gt;</literal>。"
+#, no-c-format
+msgid "A composite element mapping does not support null-able properties if you are using a <literal>&lt;set&gt;</literal>. There is no separate primary key column in the composite element table. Hibernate uses each column's value to identify a record when deleting objects, which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>."
+msgstr "è¯·æ³¨æ„å¦‚æžœä½ ä½¿ç”¨ <literal>&lt;set&gt;</literal> æ ‡ç­¾ï¼Œä¸€ä¸ªç»„åˆå…ƒç´ çš„æ˜ å°„ä¸æ”¯æŒå¯èƒ½ä¸ºç©ºçš„å±žæ€§. å½“åˆ é™¤å¯¹è±¡æ—¶ï¼ŒHibernate å¿…é¡»ä½¿ç”¨æ¯ä¸€ä¸ªå­—æ®µçš„å€¼æ¥ç¡®å®šä¸€æ¡è®°å½•ï¼ˆåœ¨ç»„åˆå…ƒç´ è¡¨ä¸­ï¼Œæ²¡æœ‰å•ç‹¬çš„å…³é”®å­—æ®µï¼‰ï¼Œå¦‚æžœæœ‰ä¸º null çš„å­—æ®µï¼Œè¿™æ ·åšå°±ä¸å¯èƒ½äº†ã€‚ä½ å¿…é¡»ä½œå‡ºä¸€ä¸ªé€‰æ‹©ï¼Œè¦ä¹ˆåœ¨ç»„åˆå…ƒç´ ä¸­ä½¿ç”¨ä¸èƒ½ä¸ºç©ºçš„å±žæ€§ï¼Œè¦ä¹ˆé€‰æ‹©ä½¿ç”¨ <literal>&lt;list&gt;</literal>，<literal>&lt;map&gt;</literal>，<literal>&lt;bag&gt;</literal> 或者 <literal>&lt;idbag&gt;</literal> 而不是 <literal>&lt;set&gt;</literal>。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A special case of a composite element is a composite element with a nested "
-"<literal>&lt;many-to-one&gt;</literal> element. This mapping allows you to "
-"map extra columns of a many-to-many association table to the composite "
-"element class. The following is a many-to-many association from "
-"<literal>Order</literal> to <literal>Item</literal>, where "
-"<literal>purchaseDate</literal>, <literal>price</literal> and "
-"<literal>quantity</literal> are properties of the association:"
-msgstr ""
-"ç»„åˆå…ƒç´ æœ‰ä¸ªç‰¹åˆ«çš„ç”¨æ³•æ˜¯å®ƒå¯ä»¥åŒ…å«ä¸€ä¸ª<literal>&lt;many-to-one&gt;</literal>"
-"å…ƒç´ ã€‚ç±»ä¼¼è¿™æ ·çš„æ˜ å°„å…è®¸ä½ å°†ä¸€ä¸ª many-to-many å…³è”è¡¨çš„é¢å¤–å­—æ®µæ˜ å°„ä¸ºç»„åˆå…ƒç´ "
-"类。接下来的的例子是从 <literal>Order</literal> 到 <literal>Item</literal> 的"
-"一个多对多的关联关系，关联属性是 <literal>purchaseDate</literal>，"
-"<literal>price</literal> 和 <literal>quantity</literal> 。"
+#, no-c-format
+msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</literal> element. This mapping allows you to map extra columns of a many-to-many association table to the composite element class. The following is a many-to-many association from <literal>Order</literal> to <literal>Item</literal>, where <literal>purchaseDate</literal>, <literal>price</literal> and <literal>quantity</literal> are properties of the association:"
+msgstr "ç»„åˆå…ƒç´ æœ‰ä¸ªç‰¹åˆ«çš„ç”¨æ³•æ˜¯å®ƒå¯ä»¥åŒ…å«ä¸€ä¸ª<literal>&lt;many-to-one&gt;</literal>å…ƒç´ ã€‚ç±»ä¼¼è¿™æ ·çš„æ˜ å°„å…è®¸ä½ å°†ä¸€ä¸ª many-to-many å…³è”è¡¨çš„é¢å¤–å­—æ®µæ˜ å°„ä¸ºç»„åˆå…ƒç´ ç±»ã€‚æŽ¥ä¸‹æ¥çš„çš„ä¾‹å­æ˜¯ä»Ž <literal>Order</literal> 到 <literal>Item</literal> 的一个多对多的关联关系，关联属性是 <literal>purchaseDate</literal>，<literal>price</literal> å’Œ <literal>quantity</literal> 。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"There cannot be a reference to the purchase on the other side for "
-"bidirectional association navigation. Components are value types and do not "
-"allow shared references. A single <literal>Purchase</literal> can be in the "
-"set of an <literal>Order</literal>, but it cannot be referenced by the "
-"<literal>Item</literal> at the same time."
-msgstr ""
-"å½“ç„¶ï¼Œå½“ä½ å®šä¹‰ Item æ—¶ï¼Œä½ æ— æ³•å¼•ç”¨è¿™äº› purchaseï¼Œå› æ­¤ä½ æ— æ³•å®žçŽ°åŒå‘å…³è”æŸ¥è¯¢ã€‚"
-"记住组件是值类型，并且不允许共享引用。某一个特定的 <literal>Purchase</"
-"literal> 可以放在 <literal>Order</literal> 的集合中，但它不能同时被 "
-"<literal>Item</literal> 所引用。"
+#, no-c-format
+msgid "There cannot be a reference to the purchase on the other side for bidirectional association navigation. Components are value types and do not allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it cannot be referenced by the <literal>Item</literal> at the same time."
+msgstr "å½“ç„¶ï¼Œå½“ä½ å®šä¹‰ Item æ—¶ï¼Œä½ æ— æ³•å¼•ç”¨è¿™äº› purchaseï¼Œå› æ­¤ä½ æ— æ³•å®žçŽ°åŒå‘å…³è”æŸ¥è¯¢ã€‚è®°ä½ç»„ä»¶æ˜¯å€¼ç±»åž‹ï¼Œå¹¶ä¸”ä¸å…è®¸å…±äº«å¼•ç”¨ã€‚æŸä¸€ä¸ªç‰¹å®šçš„ <literal>Purchase</literal> 可以放在 <literal>Order</literal> 的集合中，但它不能同时被 <literal>Item</literal> 所引用。 "
 
 #. Tag: para
 #, no-c-format
@@ -216,11 +105,9 @@
 msgstr "å…¶å®žç»„åˆå…ƒç´ çš„è¿™ä¸ªç”¨æ³•å¯ä»¥æ‰©å±•åˆ°ä¸‰é‡æˆ–å¤šé‡å…³è”:"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Composite elements can appear in queries using the same syntax as "
-"associations to other entities."
-msgstr "åœ¨æŸ¥è¯¢ä¸­ï¼Œè¡¨è¾¾ç»„åˆå…ƒç´ çš„è¯­æ³•å’Œå…³è”åˆ°å…¶ä»–å®žä½“çš„è¯­æ³•æ˜¯ä¸€æ ·çš„ã€‚"
+#, no-c-format
+msgid "Composite elements can appear in queries using the same syntax as associations to other entities."
+msgstr "åœ¨æŸ¥è¯¢ä¸­ï¼Œè¡¨è¾¾ç»„åˆå…ƒç´ çš„è¯­æ³•å’Œå…³è”åˆ°å…¶ä»–å®žä½“çš„è¯­æ³•æ˜¯ä¸€æ ·çš„ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -228,16 +115,9 @@
 msgstr "组件作为 Map 的索引（Components as Map indices ）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>&lt;composite-map-key&gt;</literal> element allows you to map a "
-"component class as the key of a <literal>Map</literal>. Ensure that you "
-"override <literal>hashCode()</literal> and <literal>equals()</literal> "
-"correctly on the component class."
-msgstr ""
-"<literal>&lt;composite-map-key&gt;</literal> å…ƒç´ å…è®¸ä½ æ˜ å°„ä¸€ä¸ªç»„ä»¶ç±»ä½œä¸ºä¸€"
-"个 <literal>Map</literal> çš„ keyï¼Œå‰ææ˜¯ä½ å¿…é¡»æ­£ç¡®çš„åœ¨è¿™ä¸ªç±»ä¸­é‡å†™äº† "
-"<literal>hashCode()</literal> 和 <literal>equals()</literal> 方法。"
+#, no-c-format
+msgid "The <literal>&lt;composite-map-key&gt;</literal> element allows you to map a component class as the key of a <literal>Map</literal>. Ensure that you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
+msgstr "<literal>&lt;composite-map-key&gt;</literal> å…ƒç´ å…è®¸ä½ æ˜ å°„ä¸€ä¸ªç»„ä»¶ç±»ä½œä¸ºä¸€ä¸ª <literal>Map</literal> çš„ keyï¼Œå‰ææ˜¯ä½ å¿…é¡»æ­£ç¡®çš„åœ¨è¿™ä¸ªç±»ä¸­é‡å†™äº† <literal>hashCode()</literal> å’Œ <literal>equals()</literal> 方法。 "
 
 #. Tag: title
 #, no-c-format
@@ -245,11 +125,9 @@
 msgstr "ç»„ä»¶ä½œä¸ºè”åˆæ ‡è¯†ç¬¦ï¼ˆComponents as composite identifiers）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can use a component as an identifier of an entity class. Your component "
-"class must satisfy certain requirements:"
-msgstr "ä½ å¯ä»¥ä½¿ç”¨ä¸€ä¸ªç»„ä»¶ä½œä¸ºä¸€ä¸ªå®žä½“ç±»çš„æ ‡è¯†ç¬¦ã€‚ä½ çš„ç»„ä»¶ç±»å¿…é¡»æ»¡è¶³ä»¥ä¸‹è¦æ±‚ï¼š"
+#, no-c-format
+msgid "You can use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
+msgstr "ä½ å¯ä»¥ä½¿ç”¨ä¸€ä¸ªç»„ä»¶ä½œä¸ºä¸€ä¸ªå®žä½“ç±»çš„æ ‡è¯†ç¬¦ã€‚ä½ çš„ç»„ä»¶ç±»å¿…é¡»æ»¡è¶³ä»¥ä¸‹è¦æ±‚ï¼š "
 
 #. Tag: para
 #, no-c-format
@@ -257,13 +135,9 @@
 msgstr "它必须实现 <literal>java.io.Serializable</literal> 接口"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It must re-implement <literal>equals()</literal> and <literal>hashCode()</"
-"literal> consistently with the database's notion of composite key equality."
-msgstr ""
-"它必须重新实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> "
-"方法，始终和组合关键字在数据库中的概念保持一致"
+#, no-c-format
+msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal> consistently with the database's notion of composite key equality."
+msgstr "它必须重新实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法，始终和组合关键字在数据库中的概念保持一致。"
 
 #. Tag: title
 #, no-c-format
@@ -271,84 +145,48 @@
 msgstr "注意"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"In Hibernate3, although the second requirement is not an absolutely hard "
-"requirement of Hibernate, it is recommended."
-msgstr ""
-"注意：在 Hibernate3 中，第二个要求并非是 Hibernate å¼ºåˆ¶å¿…é¡»çš„ã€‚ä½†æœ€å¥½è¿™æ ·åšã€‚"
+#, no-c-format
+msgid "In Hibernate3, although the second requirement is not an absolutely hard requirement of Hibernate, it is recommended."
+msgstr "注意：在 Hibernate3 中，第二个要求并非是 Hibernate å¼ºåˆ¶å¿…é¡»çš„ã€‚ä½†æœ€å¥½è¿™æ ·åšã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You cannot use an <literal>IdentifierGenerator</literal> to generate "
-"composite keys. Instead the application must assign its own identifiers."
-msgstr ""
-"ä½ ä¸èƒ½ä½¿ç”¨ä¸€ä¸ª <literal>IdentifierGenerator</literal> 产生组合关键字。一个应"
-"ç”¨ç¨‹åºå¿…é¡»åˆ†é…å®ƒè‡ªå·±çš„æ ‡è¯†ç¬¦ã€‚"
+#, no-c-format
+msgid "You cannot use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
+msgstr "ä½ ä¸èƒ½ä½¿ç”¨ä¸€ä¸ª <literal>IdentifierGenerator</literal> äº§ç”Ÿç»„åˆå…³é”®å­—ã€‚ä¸€ä¸ªåº”ç”¨ç¨‹åºå¿…é¡»åˆ†é…å®ƒè‡ªå·±çš„æ ‡è¯†ç¬¦ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Use the <literal>&lt;composite-id&gt;</literal> tag, with nested "
-"<literal>&lt;key-property&gt;</literal> elements, in place of the usual "
-"<literal>&lt;id&gt;</literal> declaration. For example, the "
-"<literal>OrderLine</literal> class has a primary key that depends upon the "
-"(composite) primary key of <literal>Order</literal>."
-msgstr ""
-"使用 <literal>&lt;composite-id&gt;</literal> æ ‡ç­¾ï¼ˆå¹¶ä¸”å†…åµŒ <literal>&lt;key-"
-"property&gt;</literal> å…ƒç´ ï¼‰ä»£æ›¿é€šå¸¸çš„ <literal>&lt;id&gt;</literal> æ ‡ç­¾ã€‚"
-"比如，<literal>OrderLine</literal> 类具有一个主键，这个主键依赖于 "
-"<literal>Order</literal> 的（联合）主键。"
+#, no-c-format
+msgid "Use the <literal>&lt;composite-id&gt;</literal> tag, with nested <literal>&lt;key-property&gt;</literal> elements, in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>."
+msgstr "使用 <literal>&lt;composite-id&gt;</literal> æ ‡ç­¾ï¼ˆå¹¶ä¸”å†…åµŒ <literal>&lt;key-property&gt;</literal> å…ƒç´ ï¼‰ä»£æ›¿é€šå¸¸çš„ <literal>&lt;id&gt;</literal> æ ‡ç­¾ã€‚æ¯”å¦‚ï¼Œ<literal>OrderLine</literal> 类具有一个主键，这个主键依赖于 <literal>Order</literal> 的（联合）主键。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Any foreign keys referencing the <literal>OrderLine</literal> table are now "
-"composite. Declare this in your mappings for other classes. An association "
-"to <literal>OrderLine</literal> is mapped like this:"
-msgstr ""
-"现在，任何指向 <literal>OrderLine</literal> çš„å¤–é”®éƒ½æ˜¯å¤åˆçš„ã€‚åœ¨ä½ çš„æ˜ å°„æ–‡ä»¶"
-"ä¸­ï¼Œå¿…é¡»ä¸ºå…¶ä»–ç±»ä¹Ÿè¿™æ ·å£°æ˜Žã€‚ä¾‹å¦‚ï¼Œä¸€ä¸ªæŒ‡å‘ <literal>OrderLine</literal> çš„å…³"
-"è”å¯èƒ½è¢«è¿™æ ·æ˜ å°„ï¼š"
+#, no-c-format
+msgid "Any foreign keys referencing the <literal>OrderLine</literal> table are now composite. Declare this in your mappings for other classes. An association to <literal>OrderLine</literal> is mapped like this:"
+msgstr "现在，任何指向 <literal>OrderLine</literal> çš„å¤–é”®éƒ½æ˜¯å¤åˆçš„ã€‚åœ¨ä½ çš„æ˜ å°„æ–‡ä»¶ä¸­ï¼Œå¿…é¡»ä¸ºå…¶ä»–ç±»ä¹Ÿè¿™æ ·å£°æ˜Žã€‚ä¾‹å¦‚ï¼Œä¸€ä¸ªæŒ‡å‘ <literal>OrderLine</literal> çš„å…³è”å¯èƒ½è¢«è¿™æ ·æ˜ å°„ï¼š "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>&lt;column&gt;</literal> tag is an alternative to the "
-"<literal>column</literal> attribute everywhere."
-msgstr ""
-"（注意在各个地方 <literal>&lt;column&gt;</literal> æ ‡ç­¾éƒ½æ˜¯ <literal>column</"
-"literal> 属性的替代写法。）"
+#, no-c-format
+msgid "The <literal>&lt;column&gt;</literal> tag is an alternative to the <literal>column</literal> attribute everywhere."
+msgstr "注意在各个地方 <literal>&lt;column&gt;</literal> æ ‡ç­¾éƒ½æ˜¯ <literal>column</literal> 属性的替代写法。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A <literal>many-to-many</literal> association to <literal>OrderLine</"
-"literal> also uses the composite foreign key:"
-msgstr ""
-"指向 <literal>OrderLine</literal> 的<literal>多对多</literal>关联也使用联合外"
-"键："
+msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
+msgstr "指向 <literal>OrderLine</literal> 的<literal>多对多</literal>关联也使用联合外键："
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The collection of <literal>OrderLine</literal>s in <literal>Order</literal> "
-"would use:"
-msgstr ""
-"在 <literal>Order</literal> 中，<literal>OrderLine</literal> çš„é›†åˆåˆ™æ˜¯è¿™æ ·ï¼š"
+#, no-c-format
+msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
+msgstr "在 <literal>Order</literal> 中，<literal>OrderLine</literal> çš„é›†åˆåˆ™æ˜¯è¿™æ ·ï¼š "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "The <literal>&lt;one-to-many&gt;</literal> element declares no columns."
-msgstr ""
-"ï¼ˆä¸Žé€šå¸¸ä¸€æ ·ï¼Œ<literal>&lt;one-to-many&gt;</literal> å…ƒç´ ä¸å£°æ˜Žä»»ä½•åˆ—.）"
+msgstr "ä¸Žé€šå¸¸ä¸€æ ·ï¼Œ<literal>&lt;one-to-many&gt;</literal> å…ƒç´ ä¸å£°æ˜Žä»»ä½•åˆ—ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If <literal>OrderLine</literal> itself owns a collection, it also has a "
-"composite foreign key."
+msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
 msgstr "假若 <literal>OrderLine</literal> 本身拥有一个集合，它也具有组合外键。"
 
 #. Tag: title
@@ -357,26 +195,14 @@
 msgstr "动态组件（Dynamic components）"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "You can also map a property of type <literal>Map</literal>:"
-msgstr "ä½ ç”šè‡³å¯ä»¥æ˜ å°„ <literal>Map</literal> 类型的属性："
+msgstr "ä½ ç”šè‡³å¯ä»¥æ˜ å°„ <literal>Map</literal> 类型的属性： "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The semantics of a <literal>&lt;dynamic-component&gt;</literal> mapping are "
-"identical to <literal>&lt;component&gt;</literal>. The advantage of this "
-"kind of mapping is the ability to determine the actual properties of the "
-"bean at deployment time just by editing the mapping document. Runtime "
-"manipulation of the mapping document is also possible, using a DOM parser. "
-"You can also access, and change, Hibernate's configuration-time metamodel "
-"via the <literal>Configuration</literal> object."
-msgstr ""
-"从 <literal>&lt;dynamic-component&gt;</literal> æ˜ å°„çš„è¯­ä¹‰ä¸Šæ¥è®²ï¼Œå®ƒå’Œ "
-"<literal>&lt;component&gt;</literal> æ˜¯ç›¸åŒçš„ã€‚è¿™ç§æ˜ å°„ç±»åž‹çš„ä¼˜ç‚¹åœ¨äºŽé€šè¿‡ä¿®æ”¹"
-"æ˜ å°„æ–‡ä»¶ï¼Œå°±å¯ä»¥å…·æœ‰åœ¨éƒ¨ç½²æ—¶æ£€æµ‹çœŸå®žå±žæ€§çš„èƒ½åŠ›ã€‚åˆ©ç”¨ä¸€ä¸ª DOM 解析器，也可以在"
-"ç¨‹åºè¿è¡Œæ—¶æ“ä½œæ˜ å°„æ–‡ä»¶ã€‚æ›´å¥½çš„æ˜¯ï¼Œä½ å¯ä»¥é€šè¿‡ <literal>Configuration</"
-"literal> 对象来访问（或者修改）Hibernate 的运行时元模型。"
+#, no-c-format
+msgid "The semantics of a <literal>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. You can also access, and change, Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
+msgstr "从 <literal>&lt;dynamic-component&gt;</literal> æ˜ å°„çš„è¯­ä¹‰ä¸Šæ¥è®²ï¼Œå®ƒå’Œ <literal>&lt;component&gt;</literal> æ˜¯ç›¸åŒçš„ã€‚è¿™ç§æ˜ å°„ç±»åž‹çš„ä¼˜ç‚¹åœ¨äºŽé€šè¿‡ä¿®æ”¹æ˜ å°„æ–‡ä»¶ï¼Œå°±å¯ä»¥å…·æœ‰åœ¨éƒ¨ç½²æ—¶æ£€æµ‹çœŸå®žå±žæ€§çš„èƒ½åŠ›ã€‚åˆ©ç”¨ä¸€ä¸ª DOM è§£æžå™¨ï¼Œä¹Ÿå¯ä»¥åœ¨ç¨‹åºè¿è¡Œæ—¶æ“ä½œæ˜ å°„æ–‡ä»¶ã€‚æ›´å¥½çš„æ˜¯ï¼Œä½ å¯ä»¥é€šè¿‡ <literal>Configuration</literal> 对象来访问（或者修改）Hibernate 的运行时元模型。 "
 
 #~ msgid ""
 #~ "<![CDATA[public class Person {\n"
@@ -430,7 +256,6 @@
 #~ "    ......\n"
 #~ "    ......\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[public class Name {\n"
 #~ "    char initial;\n"
@@ -479,7 +304,6 @@
 #~ "        this.initial = initial;\n"
 #~ "    }\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
 #~ "    <id name=\"Key\" column=\"pid\" type=\"string\">\n"
@@ -506,7 +330,6 @@
 #~ "        <property name=\"last\"/>\n"
 #~ "    </component>\n"
 #~ "</class>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<class name=\"eg.Person\" table=\"person\">\n"
 #~ "    <id name=\"Key\" column=\"pid\" type=\"string\">\n"
@@ -535,7 +358,6 @@
 #~ "        <property name=\"last\"/>\n"
 #~ "    </component>\n"
 #~ "</class>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<set name=\"someNames\" table=\"some_names\" lazy=\"true\">\n"
 #~ "    <key column=\"id\"/>\n"
@@ -756,3 +578,4 @@
 #~ "    &lt;property name=\"bar\" column=\"BAR\" type=\"integer\"/&gt;\n"
 #~ "    &lt;many-to-one name=\"baz\" class=\"Baz\" column=\"BAZ_ID\"/&gt;\n"
 #~ "&lt;/dynamic-component&gt;"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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: 2009-11-23 09:32+1000\n"
+"PO-Revision-Date: 2009-12-11 09:47+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -21,19 +21,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate is designed to operate in many different environments and, as "
-"such, there is a broad range of configuration parameters. Fortunately, most "
-"have sensible default values and Hibernate is distributed with an example "
-"<literal>hibernate.properties</literal> file in <literal>etc/</literal> that "
-"displays the various options. Simply put the example file in your classpath "
-"and customize it to suit your needs."
-msgstr ""
-"由于 Hibernate æ˜¯ä¸ºäº†èƒ½åœ¨å„ç§ä¸åŒçŽ¯å¢ƒä¸‹å·¥ä½œè€Œè®¾è®¡çš„ï¼Œå› æ­¤å­˜åœ¨ç€å¤§é‡çš„é…ç½®å‚"
-"数。幸运的是多数配置参数都有比较直观的默认值，并有随 Hibernate 一同分发的配置"
-"æ ·ä¾‹ <literal>hibernate.properties</literal>（位于 <literal>etc/</literal>）"
-"æ¥å±•ç¤ºå„ç§é…ç½®é€‰é¡¹ã€‚æ‰€éœ€åšçš„ä»…ä»…æ˜¯å°†è¿™ä¸ªæ ·ä¾‹æ–‡ä»¶å¤åˆ¶åˆ°ç±»è·¯å¾„ï¼ˆclasspath）下并"
-"进行定制。"
+msgid "Hibernate is designed to operate in many different environments and, as such, there is a broad range of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that displays the various options. Simply put the example file in your classpath and customize it to suit your needs."
+msgstr "由于 Hibernate æ˜¯ä¸ºäº†èƒ½åœ¨å„ç§ä¸åŒçŽ¯å¢ƒä¸‹å·¥ä½œè€Œè®¾è®¡çš„ï¼Œå› æ­¤å­˜åœ¨ç€å¤§é‡çš„é…ç½®å‚æ•°ã€‚å¹¸è¿çš„æ˜¯å¤šæ•°é…ç½®å‚æ•°éƒ½æœ‰æ¯”è¾ƒç›´è§‚çš„é»˜è®¤å€¼ï¼Œå¹¶æœ‰éš Hibernate ä¸€åŒåˆ†å‘çš„é…ç½®æ ·ä¾‹ <literal>hibernate.properties</literal>（位于 <literal>etc/</literal>ï¼‰æ¥å±•ç¤ºå„ç§é…ç½®é€‰é¡¹ã€‚æ‰€éœ€åšçš„ä»…ä»…æ˜¯å°†è¿™ä¸ªæ ·ä¾‹æ–‡ä»¶å¤åˆ¶åˆ°ç±»è·¯å¾„ï¼ˆclasspath）下并进行定制。"
 
 #. Tag: title
 #, no-c-format
@@ -42,124 +31,63 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An instance of <classname>org.hibernate.cfg.Configuration</classname> "
-"represents an entire set of mappings of an application's Java types to an "
-"SQL database. The <classname>org.hibernate.cfg.Configuration</classname> is "
-"used to build an immutable <interfacename>org.hibernate.SessionFactory</"
-"interfacename>. The mappings are compiled from various XML mapping files."
-msgstr ""
-"<literal>org.hibernate.cfg.Configuration</literal> 实例代表了一个应用程序中 "
-"Java 类型到SQLæ•°æ®åº“æ˜ å°„çš„å®Œæ•´é›†åˆã€‚<classname>org.hibernate.cfg."
-"Configuration</classname> 被用来构建一个（不可变的（immutable））"
-"<interfacename>org.hibernate.SessionFactory</interfacename>ã€‚æ˜ å°„å®šä¹‰åˆ™ç”±ä¸åŒ"
-"çš„ XML æ˜ å°„å®šä¹‰æ–‡ä»¶ç¼–è¯‘è€Œæ¥ã€‚"
+msgid "An instance of <classname>org.hibernate.cfg.Configuration</classname> represents an entire set of mappings of an application's Java types to an SQL database. The <classname>org.hibernate.cfg.Configuration</classname> is used to build an immutable <interfacename>org.hibernate.SessionFactory</interfacename>. The mappings are compiled from various XML mapping files."
+msgstr "<literal>org.hibernate.cfg.Configuration</literal> 实例代表了一个应用程序中 Java 类型到SQLæ•°æ®åº“æ˜ å°„çš„å®Œæ•´é›†åˆã€‚<classname>org.hibernate.cfg.Configuration</classname> 被用来构建一个（不可变的（immutable））<interfacename>org.hibernate.SessionFactory</interfacename>ã€‚æ˜ å°„å®šä¹‰åˆ™ç”±ä¸åŒçš„ XML æ˜ å°„å®šä¹‰æ–‡ä»¶ç¼–è¯‘è€Œæ¥ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can obtain a <classname>org.hibernate.cfg.Configuration</classname> "
-"instance by instantiating it directly and specifying XML mapping documents. "
-"If the mapping files are in the classpath, use <literal>addResource()</"
-"literal>. For example:"
-msgstr ""
-"ä½ å¯ä»¥ç›´æŽ¥å®žä¾‹åŒ– <classname>org.hibernate.cfg.Configuration</classname> 来获"
-"取一个实例，并为它指定 XML æ˜ å°„å®šä¹‰æ–‡ä»¶ã€‚å¦‚æžœæ˜ å°„å®šä¹‰æ–‡ä»¶åœ¨ç±»è·¯å¾„"
-"（classpath）中，请使用 <literal>addResource（)</literal>。例如："
+msgid "You can obtain a <classname>org.hibernate.cfg.Configuration</classname> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>. For example:"
+msgstr "ä½ å¯ä»¥ç›´æŽ¥å®žä¾‹åŒ– <classname>org.hibernate.cfg.Configuration</classname> 来获取一个实例，并为它指定 XML æ˜ å°„å®šä¹‰æ–‡ä»¶ã€‚å¦‚æžœæ˜ å°„å®šä¹‰æ–‡ä»¶åœ¨ç±»è·¯å¾„ï¼ˆclasspath）中，请使用 <literal>addResource（)</literal>。例如："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An alternative way is to specify the mapped class and allow Hibernate to "
-"find the mapping document for you:"
-msgstr ""
-"ä¸€ä¸ªæ›¿ä»£æ–¹æ³•ï¼ˆæœ‰æ—¶æ˜¯æ›´å¥½çš„é€‰æ‹©ï¼‰æ˜¯ï¼ŒæŒ‡å®šè¢«æ˜ å°„çš„ç±»ï¼Œè®© Hibernate å¸®ä½ å¯»æ‰¾æ˜ å°„"
-"定义文件： "
+msgid "An alternative way is to specify the mapped class and allow Hibernate to find the mapping document for you:"
+msgstr "ä¸€ä¸ªæ›¿ä»£æ–¹æ³•ï¼ˆæœ‰æ—¶æ˜¯æ›´å¥½çš„é€‰æ‹©ï¼‰æ˜¯ï¼ŒæŒ‡å®šè¢«æ˜ å°„çš„ç±»ï¼Œè®© Hibernate å¸®ä½ å¯»æ‰¾æ˜ å°„å®šä¹‰æ–‡ä»¶ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate will then search for mapping files named <filename>/org/hibernate/"
-"auction/Item.hbm.xml</filename> and <filename>/org/hibernate/auction/Bid.hbm."
-"xml</filename> in the classpath. This approach eliminates any hardcoded "
-"filenames."
-msgstr ""
-"Hibernate 将会在类路径（classpath）中寻找名字为 <filename>/org/hibernate/"
-"auction/Item.hbm.xml</filename> 和 <filename>/org/hibernate/auction/Bid.hbm."
-"xml</filename> æ˜ å°„å®šä¹‰æ–‡ä»¶ã€‚è¿™ç§æ–¹å¼æ¶ˆé™¤äº†ä»»ä½•å¯¹æ–‡ä»¶åçš„ç¡¬ç¼–ç "
-"（hardcoded）。"
+msgid "Hibernate will then search for mapping files named <filename>/org/hibernate/auction/Item.hbm.xml</filename> and <filename>/org/hibernate/auction/Bid.hbm.xml</filename> in the classpath. This approach eliminates any hardcoded filenames."
+msgstr "Hibernate 将会在类路径（classpath）中寻找名字为 <filename>/org/hibernate/auction/Item.hbm.xml</filename> å’Œ <filename>/org/hibernate/auction/Bid.hbm.xml</filename> æ˜ å°„å®šä¹‰æ–‡ä»¶ã€‚è¿™ç§æ–¹å¼æ¶ˆé™¤äº†ä»»ä½•å¯¹æ–‡ä»¶åçš„ç¡¬ç¼–ç ï¼ˆhardcoded）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A <classname>org.hibernate.cfg.Configuration</classname> also allows you to "
-"specify configuration properties. For example:"
-msgstr ""
-"<classname>org.hibernate.cfg.Configuration</classname>> ä¹Ÿå…è®¸ä½ æŒ‡å®šé…ç½®å±ž"
-"性。例如："
+msgid "A <classname>org.hibernate.cfg.Configuration</classname> also allows you to specify configuration properties. For example:"
+msgstr "<classname>org.hibernate.cfg.Configuration</classname>> ä¹Ÿå…è®¸ä½ æŒ‡å®šé…ç½®å±žæ€§ã€‚ä¾‹å¦‚ï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This is not the only way to pass configuration properties to Hibernate. Some "
-"alternative options include:"
+msgid "This is not the only way to pass configuration properties to Hibernate. Some alternative options include:"
 msgstr "å½“ç„¶è¿™ä¸æ˜¯å”¯ä¸€çš„ä¼ é€’ Hibernate 配置属性的方式，其他可选方式还包括： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Pass an instance of <classname>java.util.Properties</classname> to "
-"<literal>Configuration.setProperties()</literal>."
-msgstr ""
-"ä¼ ä¸€ä¸ª <classname>java.util.Properties</classname> 实例给 "
-"<literal>Configuration.setProperties()</literal>。"
+msgid "Pass an instance of <classname>java.util.Properties</classname> to <literal>Configuration.setProperties()</literal>."
+msgstr "ä¼ ä¸€ä¸ª <classname>java.util.Properties</classname> 实例给 <literal>Configuration.setProperties()</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Place a file named <filename>hibernate.properties</filename> in a root "
-"directory of the classpath."
-msgstr ""
-"å°† <filename>hibernate.properties</filename> 放置在类路径（classpathï¼‰çš„æ ¹ç›®"
-"录下（root directory）。"
+msgid "Place a file named <filename>hibernate.properties</filename> in a root directory of the classpath."
+msgstr "å°† <filename>hibernate.properties</filename> 放置在类路径（classpathï¼‰çš„æ ¹ç›®å½•ä¸‹ï¼ˆroot directory）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Set <literal>System</literal> properties using <literal>java -"
-"Dproperty=value</literal>."
-msgstr ""
-"通过 <literal>java -Dproperty=value</literal> 来设置系统（<literal>System</"
-"literal>）属性。"
+msgid "Set <literal>System</literal> properties using <literal>java -Dproperty=value</literal>."
+msgstr "通过 <literal>java -Dproperty=value</literal> 来设置系统（<literal>System</literal>）属性。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Include <literal>&lt;property&gt;</literal> elements in <literal>hibernate."
-"cfg.xml</literal> (this is discussed later)."
-msgstr ""
-"在 <literal>hibernate.cfg.xml</literal> ä¸­åŠ å…¥å…ƒç´  <literal>&lt;property&gt;"
-"</literal>（稍后讨论）。 "
+msgid "Include <literal>&lt;property&gt;</literal> elements in <literal>hibernate.cfg.xml</literal> (this is discussed later)."
+msgstr "在 <literal>hibernate.cfg.xml</literal> ä¸­åŠ å…¥å…ƒç´  <literal>&lt;property&gt;</literal>（稍后讨论）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you want to get started quickly<filename>hibernate.properties</filename> "
-"is the easiest approach."
-msgstr ""
-"å¦‚æžœä½ æƒ³å¿«é€Ÿä¸Šè·¯ï¼Œ<filename>hibernate.properties</filename> 就是最容易的途"
-"径。"
+msgid "If you want to get started quickly<filename>hibernate.properties</filename> is the easiest approach."
+msgstr "å¦‚æžœä½ æƒ³å¿«é€Ÿä¸Šè·¯ï¼Œ<filename>hibernate.properties</filename> 就是最容易的途径。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <classname>org.hibernate.cfg.Configuration</classname> is intended as a "
-"startup-time object that will be discarded once a <literal>SessionFactory</"
-"literal> is created."
-msgstr ""
-"<classname>org.hibernate.cfg.Configuration</classname> 实例被设计成启动期间"
-"（startup-time）对象，一旦 <literal>SessionFactory</literal> 创建完成它就被丢"
-"弃了。"
+msgid "The <classname>org.hibernate.cfg.Configuration</classname> is intended as a startup-time object that will be discarded once a <literal>SessionFactory</literal> is created."
+msgstr "<classname>org.hibernate.cfg.Configuration</classname> 实例被设计成启动期间（startup-time）对象，一旦 <literal>SessionFactory</literal> 创建完成它就被丢弃了。"
 
 #. Tag: title
 #, no-c-format
@@ -168,25 +96,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"When all mappings have been parsed by the <classname>org.hibernate.cfg."
-"Configuration</classname>, the application must obtain a factory for "
-"<interfacename>org.hibernate.Session</interfacename> instances. This factory "
-"is intended to be shared by all application threads:"
-msgstr ""
-"å½“æ‰€æœ‰æ˜ å°„å®šä¹‰è¢« <classname>org.hibernate.cfg.Configuration</classname> 解析"
-"åŽï¼Œåº”ç”¨ç¨‹åºå¿…é¡»èŽ·å¾—ä¸€ä¸ªç”¨äºŽæž„é€  <interfacename>org.hibernate.Session</"
-"interfacename> 实例的工厂。这个工厂将被应用程序的所有线程共享："
+msgid "When all mappings have been parsed by the <classname>org.hibernate.cfg.Configuration</classname>, the application must obtain a factory for <interfacename>org.hibernate.Session</interfacename> instances. This factory is intended to be shared by all application threads:"
+msgstr "å½“æ‰€æœ‰æ˜ å°„å®šä¹‰è¢« <classname>org.hibernate.cfg.Configuration</classname> è§£æžåŽï¼Œåº”ç”¨ç¨‹åºå¿…é¡»èŽ·å¾—ä¸€ä¸ªç”¨äºŽæž„é€  <interfacename>org.hibernate.Session</interfacename> 实例的工厂。这个工厂将被应用程序的所有线程共享："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate does allow your application to instantiate more than one "
-"<interfacename>org.hibernate.SessionFactory</interfacename>. This is useful "
-"if you are using more than one database."
-msgstr ""
-"Hibernate å…è®¸ä½ çš„åº”ç”¨ç¨‹åºåˆ›å»ºå¤šä¸ª <interfacename>org.hibernate."
-"SessionFactory</interfacename> 实例。这对 使用多个数据库的应用来说很有用。"
+msgid "Hibernate does allow your application to instantiate more than one <interfacename>org.hibernate.SessionFactory</interfacename>. This is useful if you are using more than one database."
+msgstr "Hibernate å…è®¸ä½ çš„åº”ç”¨ç¨‹åºåˆ›å»ºå¤šä¸ª <interfacename>org.hibernate.SessionFactory</interfacename> 实例。这对 使用多个数据库的应用来说很有用。"
 
 #. Tag: title
 #, no-c-format
@@ -195,46 +111,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is advisable to have the <interfacename>org.hibernate.SessionFactory</"
-"interfacename> create and pool JDBC connections for you. If you take this "
-"approach, opening a <interfacename>org.hibernate.Session</interfacename> is "
-"as simple as:"
-msgstr ""
-"é€šå¸¸ä½ å¸Œæœ›  <interfacename>org.hibernate.SessionFactory</interfacename> 来为"
-"ä½ åˆ›å»ºå’Œç¼“å­˜ï¼ˆpool）JDBC è¿žæŽ¥ã€‚å¦‚æžœä½ é‡‡ç”¨è¿™ç§æ–¹å¼ï¼Œåªéœ€è¦å¦‚ä¸‹ä¾‹æ‰€ç¤ºé‚£æ ·ï¼Œæ‰“å¼€"
-"一个 <interfacename>org.hibernate.Session</interfacename>："
+msgid "It is advisable to have the <interfacename>org.hibernate.SessionFactory</interfacename> create and pool JDBC connections for you. If you take this approach, opening a <interfacename>org.hibernate.Session</interfacename> is as simple as:"
+msgstr "é€šå¸¸ä½ å¸Œæœ›  <interfacename>org.hibernate.SessionFactory</interfacename> æ¥ä¸ºä½ åˆ›å»ºå’Œç¼“å­˜ï¼ˆpool）JDBC è¿žæŽ¥ã€‚å¦‚æžœä½ é‡‡ç”¨è¿™ç§æ–¹å¼ï¼Œåªéœ€è¦å¦‚ä¸‹ä¾‹æ‰€ç¤ºé‚£æ ·ï¼Œæ‰“å¼€ä¸€ä¸ª <interfacename>org.hibernate.Session</interfacename>："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Once you start a task that requires access to the database, a JDBC "
-"connection will be obtained from the pool."
-msgstr ""
-"ä¸€æ—¦ä½ éœ€è¦è¿›è¡Œæ•°æ®è®¿é—®æ—¶ï¼Œå°±ä¼šä»Žè¿žæŽ¥æ± ï¼ˆconnection pool）获得一个 JDBC è¿ž"
-"接。 "
+msgid "Once you start a task that requires access to the database, a JDBC connection will be obtained from the pool."
+msgstr "ä¸€æ—¦ä½ éœ€è¦è¿›è¡Œæ•°æ®è®¿é—®æ—¶ï¼Œå°±ä¼šä»Žè¿žæŽ¥æ± ï¼ˆconnection pool）获得一个 JDBC 连接。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Before you can do this, you first need to pass some JDBC connection "
-"properties to Hibernate. All Hibernate property names and semantics are "
-"defined on the class <classname>org.hibernate.cfg.Environment</classname>. "
-"The most important settings for JDBC connection configuration are outlined "
-"below."
-msgstr ""
-"为了使这种方式工作起来，我们需要向 Hibernate ä¼ é€’ä¸€äº› JDBC 连接的属性。所有 "
-"Hibernate 属性的名字和语义都在 <classname>org.hibernate.cfg.Environment</"
-"classname> 中定义。我们现在将描述 JDBC 连接配置中最重要的设置。"
+msgid "Before you can do this, you first need to pass some JDBC connection properties to Hibernate. All Hibernate property names and semantics are defined on the class <classname>org.hibernate.cfg.Environment</classname>. The most important settings for JDBC connection configuration are outlined below."
+msgstr "为了使这种方式工作起来，我们需要向 Hibernate ä¼ é€’ä¸€äº› JDBC 连接的属性。所有 Hibernate 属性的名字和语义都在 <classname>org.hibernate.cfg.Environment</classname> 中定义。我们现在将描述 JDBC 连接配置中最重要的设置。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate will obtain and pool connections using <classname>java.sql."
-"DriverManager</classname> if you set the following properties:"
-msgstr ""
-"å¦‚æžœä½ è®¾ç½®å¦‚ä¸‹å±žæ€§ï¼ŒHibernate 将使用 <classname>java.sql.DriverManager</"
-"classname> 来获得（和缓存）JDBC 连接："
+msgid "Hibernate will obtain and pool connections using <classname>java.sql.DriverManager</classname> if you set the following properties:"
+msgstr "å¦‚æžœä½ è®¾ç½®å¦‚ä¸‹å±žæ€§ï¼ŒHibernate 将使用 <classname>java.sql.DriverManager</classname> 来获得（和缓存）JDBC 连接："
 
 #. Tag: title
 #, no-c-format
@@ -252,108 +145,74 @@
 msgstr "用途"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.driver_class</property>"
-msgstr "hibernate.connection.driver_class"
+msgstr "<property>hibernate.connection.driver_class</property>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<emphasis>JDBC driver class</emphasis>"
-msgstr "JDBC 驱动 class"
+msgstr "<emphasis>JDBC 驱动类</emphasis>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.url</property>"
-msgstr "hibernate.connection.url"
+msgstr "<property>hibernate.connection.url</property>"
 
 #. Tag: entry
 #, no-c-format
 msgid "<emphasis>JDBC URL</emphasis>"
-msgstr ""
+msgstr "<emphasis>JDBC URL</emphasis>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.username</property>"
-msgstr "hibernate.connection.username"
+msgstr "<property>hibernate.connection.username</property>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<emphasis>database user</emphasis>"
-msgstr "<emphasis>数据库用户</emphasis>（可选）"
+msgstr "<emphasis>数据库用户</emphasis>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.password</property>"
-msgstr "hibernate.connection.password"
+msgstr "<property>hibernate.connection.password</property>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<emphasis>database user password</emphasis>"
-msgstr "<emphasis>æ•°æ®åº“å¯†ç </emphasis>（可选）"
+msgstr "<emphasis>æ•°æ®åº“å¯†ç </emphasis> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.pool_size</property>"
-msgstr "hibernate.connection.pool_size"
+msgstr "<property>hibernate.connection.pool_size</property>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<emphasis>maximum number of pooled connections</emphasis>"
-msgstr "è¿žæŽ¥æ± å®¹é‡ä¸Šé™æ•°ç›®"
+msgstr "<emphasis>è¿žæŽ¥æ± å®¹é‡ä¸Šé™æ•°ç›®</emphasis>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate's own connection pooling algorithm is, however, quite rudimentary. "
-"It is intended to help you get started and is <emphasis>not intended for use "
-"in a production system</emphasis>, or even for performance testing. You "
-"should use a third party pool for best performance and stability. Just "
-"replace the <property>hibernate.connection.pool_size</property> property "
-"with connection pool specific settings. This will turn off Hibernate's "
-"internal pool. For example, you might like to use c3p0."
-msgstr ""
-"但 Hibernate è‡ªå¸¦çš„è¿žæŽ¥æ± ç®—æ³•ç›¸å½“ä¸æˆç†Ÿã€‚å®ƒåªæ˜¯ä¸ºäº†è®©ä½ å¿«äº›ä¸Šæ‰‹<emphasis>，并"
-"不适合用于产品系统</emphasis>或性能测试中。 å‡ºäºŽæœ€ä½³æ€§èƒ½å’Œç¨³å®šæ€§è€ƒè™‘ä½ åº”è¯¥ä½¿"
-"ç”¨ç¬¬ä¸‰æ–¹çš„è¿žæŽ¥æ± ã€‚åªéœ€è¦ç”¨ç‰¹å®šè¿žæŽ¥æ± çš„è®¾ç½®æ›¿æ¢ <literal>hibernate.connection."
-"pool_size</literal> 即可。这将关闭 Hibernate è‡ªå¸¦çš„è¿žæŽ¥æ± ã€‚ä¾‹å¦‚ï¼Œä½ å¯èƒ½ä¼šæƒ³"
-"用 C3P0。  "
+msgid "Hibernate's own connection pooling algorithm is, however, quite rudimentary. It is intended to help you get started and is <emphasis>not intended for use in a production system</emphasis>, or even for performance testing. You should use a third party pool for best performance and stability. Just replace the <property>hibernate.connection.pool_size</property> property with connection pool specific settings. This will turn off Hibernate's internal pool. For example, you might like to use c3p0."
+msgstr "但 Hibernate è‡ªå¸¦çš„è¿žæŽ¥æ± ç®—æ³•ç›¸å½“ä¸æˆç†Ÿã€‚å®ƒåªæ˜¯ä¸ºäº†è®©ä½ å¿«äº›ä¸Šæ‰‹<emphasis>，并不适合用于产品系统</emphasis>或性能测试中。 å‡ºäºŽæœ€ä½³æ€§èƒ½å’Œç¨³å®šæ€§è€ƒè™‘ä½ åº”è¯¥ä½¿ç”¨ç¬¬ä¸‰æ–¹çš„è¿žæŽ¥æ± ã€‚åªéœ€è¦ç”¨ç‰¹å®šè¿žæŽ¥æ± çš„è®¾ç½®æ›¿æ¢ <literal>hibernate.connection.pool_size</literal> 即可。这将关闭 Hibernate è‡ªå¸¦çš„è¿žæŽ¥æ± ã€‚ä¾‹å¦‚ï¼Œä½ å¯èƒ½ä¼šæƒ³ç”¨ C3P0。  "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"C3P0 is an open source JDBC connection pool distributed along with Hibernate "
-"in the <filename>lib</filename> directory. Hibernate will use its "
-"<classname>org.hibernate.connection.C3P0ConnectionProvider</classname> for "
-"connection pooling if you set <property>hibernate.c3p0.*</property> "
-"properties. If you would like to use Proxool, refer to the packaged "
-"<filename>hibernate.properties</filename> and the Hibernate web site for "
-"more information."
-msgstr ""
-"C3P0 是一个随 Hibernate 一同分发的开源的 JDBC è¿žæŽ¥æ± ï¼Œå®ƒä½äºŽ <literal>lib</"
-"literal>目录下。 å¦‚æžœä½ è®¾ç½®äº† <literal>hibernate.c3p0.*</literal> 相关的属"
-"性，Hibernate将使用 <literal>C3P0ConnectionProvider</literal> 来缓存 JDBC 连"
-"æŽ¥ã€‚å¦‚æžœä½ æ›´åŽŸæ„ä½¿ç”¨ Proxool，请参考发行包中的 <literal>hibernate."
-"properties</literal> 并到 Hibernate 网站获取更多的信息。 "
+msgid "C3P0 is an open source JDBC connection pool distributed along with Hibernate in the <filename>lib</filename> directory. Hibernate will use its <classname>org.hibernate.connection.C3P0ConnectionProvider</classname> for connection pooling if you set <property>hibernate.c3p0.*</property> properties. If you would like to use Proxool, refer to the packaged <filename>hibernate.properties</filename> and the Hibernate web site for more information."
+msgstr "C3P0 是一个随 Hibernate 一同分发的开源的 JDBC è¿žæŽ¥æ± ï¼Œå®ƒä½äºŽ <literal>lib</literal>目录下。 å¦‚æžœä½ è®¾ç½®äº† <literal>hibernate.c3p0.*</literal> 相关的属性，Hibernate将使用 <literal>C3P0ConnectionProvider</literal> 来缓存 JDBC è¿žæŽ¥ã€‚å¦‚æžœä½ æ›´åŽŸæ„ä½¿ç”¨ Proxool，请参考发行包中的 <literal>hibernate.properties</literal> 并到 Hibernate 网站获取更多的信息。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The following is an example <filename>hibernate.properties</filename> file "
-"for c3p0:"
-msgstr ""
-"这是一个使用 C3P0 çš„ <literal>hibernate.properties</literal> æ ·ä¾‹æ–‡ä»¶ï¼š "
+msgid "The following is an example <filename>hibernate.properties</filename> file for c3p0:"
+msgstr "这是一个使用 C3P0 çš„ <literal>hibernate.properties</literal> æ ·ä¾‹æ–‡ä»¶ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For use inside an application server, you should almost always configure "
-"Hibernate to obtain connections from an application server "
-"<interfacename>javax.sql.Datasource</interfacename> registered in JNDI. You "
-"will need to set at least one of the following properties:"
-msgstr ""
-"为了能在应用程序服务器（application server）中使用 Hibernate，应当总是将 "
-"Hibernate 配置成从注册在 JNDI 中的 <literal>Datasource</literal> 处获得连接，"
-"ä½ è‡³å°‘éœ€è¦è®¾ç½®ä¸‹åˆ—å±žæ€§ä¸­çš„ä¸€ä¸ªï¼š "
+msgid "For use inside an application server, you should almost always configure Hibernate to obtain connections from an application server <interfacename>javax.sql.Datasource</interfacename> registered in JNDI. You will need to set at least one of the following properties:"
+msgstr "为了能在应用程序服务器（application server）中使用 Hibernate，应当总是将 Hibernate 配置成从注册在 JNDI 中的 <literal>Datasource</literal> å¤„èŽ·å¾—è¿žæŽ¥ï¼Œä½ è‡³å°‘éœ€è¦è®¾ç½®ä¸‹åˆ—å±žæ€§ä¸­çš„ä¸€ä¸ªï¼š "
 
 #. Tag: title
 #, no-c-format
@@ -361,19 +220,19 @@
 msgstr "Hibernate 数据源属性"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.datasource</property>"
-msgstr "hibernate.connection.datasource"
+msgstr "<property>hibernate.connection.datasource</property>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<emphasis>datasource JNDI name</emphasis>"
-msgstr "<emphasis>数据库用户</emphasis>（可选）"
+msgstr "<emphasis>datasource JNDI name</emphasis>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jndi.url</property>"
-msgstr "hibernate.jndi.url"
+msgstr "<property>hibernate.jndi.url</property>"
 
 #. Tag: entry
 #, no-c-format
@@ -381,17 +240,14 @@
 msgstr "<emphasis>JNDI 提供者的 URL</emphasis>（可选）"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jndi.class</property>"
-msgstr "hibernate.jndi.class"
+msgstr "<property>hibernate.jndi.class</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"<emphasis>class of the JNDI <literal>InitialContextFactory</literal></"
-"emphasis> (optional)"
-msgstr ""
-"<emphasis>JNDI <literal>InitialContextFactory</literal> 类</emphasis>（可选）"
+msgid "<emphasis>class of the JNDI <literal>InitialContextFactory</literal></emphasis> (optional)"
+msgstr "<emphasis>JNDI <literal>InitialContextFactory</literal> 类</emphasis>（可选）"
 
 #. Tag: entry
 #, no-c-format
@@ -405,46 +261,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Here is an example <filename>hibernate.properties</filename> file for an "
-"application server provided JNDI datasource:"
-msgstr ""
-"这是一个使用应用程序服务器提供的 JNDI 数据源的 <literal>hibernate."
-"properties</literal> æ ·ä¾‹æ–‡ä»¶ï¼š "
+msgid "Here is an example <filename>hibernate.properties</filename> file for an application server provided JNDI datasource:"
+msgstr "这是一个使用应用程序服务器提供的 JNDI 数据源的 <literal>hibernate.properties</literal> æ ·ä¾‹æ–‡ä»¶ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"JDBC connections obtained from a JNDI datasource will automatically "
-"participate in the container-managed transactions of the application server."
-msgstr ""
-"从 JNDI 数据源获得的 JDBC 连接将自动参与到应用程序服务器中容器管理的事务"
-"（container-managed transactions）中去。"
+msgid "JDBC connections obtained from a JNDI datasource will automatically participate in the container-managed transactions of the application server."
+msgstr "从 JNDI 数据源获得的 JDBC 连接将自动参与到应用程序服务器中容器管理的事务（container-managed transactions）中去。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Arbitrary connection properties can be given by prepending "
-"\"<literal>hibernate.connection</literal>\" to the connection property name. "
-"For example, you can specify a <property>charSet</property> connection "
-"property using <property>hibernate.connection.charSet</property>."
-msgstr ""
-"任何连接（connection）属性的属性名都要以 \"<literal>hibernate.connnection</"
-"literal>\" å¼€å¤´ã€‚ä¾‹å¦‚ï¼Œä½ å¯èƒ½ä¼šä½¿ç”¨ <literal>hibernate.connection.charSet</"
-"literal> 来指定 <property>charSet</property> 连接属性。 "
+msgid "Arbitrary connection properties can be given by prepending \"<literal>hibernate.connection</literal>\" to the connection property name. For example, you can specify a <property>charSet</property> connection property using <property>hibernate.connection.charSet</property>."
+msgstr "任何连接（connection）属性的属性名都要以 \"<literal>hibernate.connnection</literal>\" å¼€å¤´ã€‚ä¾‹å¦‚ï¼Œä½ å¯èƒ½ä¼šä½¿ç”¨ <literal>hibernate.connection.charSet</literal> 来指定 <property>charSet</property> 连接属性。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can define your own plugin strategy for obtaining JDBC connections by "
-"implementing the interface <interfacename>org.hibernate.connection."
-"ConnectionProvider</interfacename>, and specifying your custom "
-"implementation via the <property>hibernate.connection.provider_class</"
-"property> property."
-msgstr ""
-"通过实现 <literal>org.hibernate.connection.ConnectionProvider</literal> 接"
-"å£ï¼Œä½ å¯ä»¥å®šä¹‰å±žäºŽä½ è‡ªå·±çš„èŽ·å¾—JDBC连接的插件策略。通过设置<literal>hibernate."
-"connection.provider_class</literal>ï¼Œä½ å¯ä»¥é€‰æ‹©ä¸€ä¸ªè‡ªå®šä¹‰çš„å®žçŽ°ã€‚ "
+msgid "You can define your own plugin strategy for obtaining JDBC connections by implementing the interface <interfacename>org.hibernate.connection.ConnectionProvider</interfacename>, and specifying your custom implementation via the <property>hibernate.connection.provider_class</property> property."
+msgstr "通过实现 <literal>org.hibernate.connection.ConnectionProvider</literal> æŽ¥å£ï¼Œä½ å¯ä»¥å®šä¹‰å±žäºŽä½ è‡ªå·±çš„èŽ·å¾—JDBC连接的插件策略。通过设置<literal>hibernate.connection.provider_class</literal>ï¼Œä½ å¯ä»¥é€‰æ‹©ä¸€ä¸ªè‡ªå®šä¹‰çš„å®žçŽ°ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -453,24 +286,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"There are a number of other properties that control the behavior of "
-"Hibernate at runtime. All are optional and have reasonable default values."
-msgstr ""
-"有大量属性能用来控制 Hibernate 在运行期的行为。它们都是可选的，并拥有适当的默"
-"认值。 "
+msgid "There are a number of other properties that control the behavior of Hibernate at runtime. All are optional and have reasonable default values."
+msgstr "有大量属性能用来控制 Hibernate 在运行期的行为。它们都是可选的，并拥有适当的默认值。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Some of these properties are system-level only. System-level properties can "
-"be set only via <code>java -Dproperty=value</code> or <filename>hibernate."
-"properties</filename>. They <emphasis>cannot</emphasis> be set by the other "
-"techniques described above."
-msgstr ""
-"警告： 其中一些属性是\"系统级（system-level）的\"。系统级属性只能通过"
-"<literal>java -Dproperty=value</literal> 或 <literal>hibernate.properties</"
-"literal> 来设置，而<emphasis>不能</emphasis>用上面描述的其他方法来设置。 "
+msgid "Some of these properties are system-level only. System-level properties can be set only via <code>java -Dproperty=value</code> or <filename>hibernate.properties</filename>. They <emphasis>cannot</emphasis> be set by the other techniques described above."
+msgstr "警告： 其中一些属性是\"系统级（system-level）的\"。系统级属性只能通过<literal>java -Dproperty=value</literal> 或 <literal>hibernate.properties</literal> 来设置，而<emphasis>不能</emphasis>用上面描述的其他方法来设置。 "
 
 #. Tag: title
 #, no-c-format
@@ -478,68 +300,44 @@
 msgstr "Hibernate 配置属性"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.dialect</property>"
-msgstr "hibernate.dialect"
+msgstr "<property>hibernate.dialect</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"The classname of a Hibernate <classname>org.hibernate.dialect.Dialect</"
-"classname> which allows Hibernate to generate SQL optimized for a particular "
-"relational database."
-msgstr ""
-"允许 Hibernate 针对特定的关系数据库生成优化的 SQL 的 <classname>org."
-"hibernate.dialect.Dialect</classname> 的类名。"
+msgid "The classname of a Hibernate <classname>org.hibernate.dialect.Dialect</classname> which allows Hibernate to generate SQL optimized for a particular relational database."
+msgstr "允许 Hibernate 针对特定的关系数据库生成优化的 SQL 的 <classname>org.hibernate.dialect.Dialect</classname> 的类名。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>full.classname.of."
-"Dialect</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>full.classname.of."
-"Dialect</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>full.classname.of.Dialect</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>full.classname.of.Dialect</literal> "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In most cases Hibernate will actually be able to choose the correct "
-"<classname>org.hibernate.dialect.Dialect</classname> implementation based on "
-"the <literal>JDBC metadata</literal> returned by the JDBC driver."
-msgstr ""
-"在大多数情况下，Hibernate å¯ä»¥æ ¹æ® JDBC 驱动返回的 <literal>JDBC metadata</"
-"literal> 选择正确的 <classname>org.hibernate.dialect.Dialect</classname> 实"
-"现。"
+msgid "In most cases Hibernate will actually be able to choose the correct <classname>org.hibernate.dialect.Dialect</classname> implementation based on the <literal>JDBC metadata</literal> returned by the JDBC driver."
+msgstr "在大多数情况下，Hibernate å¯ä»¥æ ¹æ® JDBC 驱动返回的 <literal>JDBC metadata</literal> 选择正确的 <classname>org.hibernate.dialect.Dialect</classname> 实现。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.show_sql</property>"
-msgstr "hibernate.show_sql"
+msgstr "<property>hibernate.show_sql</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Write all SQL statements to console. This is an alternative to setting the "
-"log category <literal>org.hibernate.SQL</literal> to <literal>debug</"
-"literal>."
-msgstr ""
-"输出所有 SQL 语句到控制台。有一个另外的选择是把 <literal>org.hibernate.SQL</"
-"literal> 这个 log category设为 <literal>debug</literal>。"
+msgid "Write all SQL statements to console. This is an alternative to setting the log category <literal>org.hibernate.SQL</literal> to <literal>debug</literal>."
+msgstr "输出所有 SQL 语句到控制台。有一个另外的选择是把 <literal>org.hibernate.SQL</literal> 这个 log category设为 <literal>debug</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>true</literal> | "
-"<literal>false</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>true</literal> | "
-"<literal>false</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>true</literal> | <literal>false</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>true</literal> | <literal>false</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.format_sql</property>"
-msgstr "hibernate.format_sql"
+msgstr "<property>hibernate.format_sql</property>"
 
 #. Tag: entry
 #, no-c-format
@@ -547,94 +345,69 @@
 msgstr "在 log 和 console 中打印出更漂亮的 SQL。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.default_schema</property>"
-msgstr "hibernate.default_schema"
+msgstr "<property>hibernate.default_schema</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Qualify unqualified table names with the given schema/tablespace in "
-"generated SQL."
-msgstr ""
-"在生成的 SQL 中，将给定的 schema/tablespace é™„åŠ äºŽéžå…¨é™å®šåçš„è¡¨åä¸Šã€‚ "
+msgid "Qualify unqualified table names with the given schema/tablespace in generated SQL."
+msgstr "在生成的 SQL 中，将给定的 schema/tablespace é™„åŠ äºŽéžå…¨é™å®šåçš„è¡¨åä¸Šã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>SCHEMA_NAME</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>SCHEMA_NAME</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>SCHEMA_NAME</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>SCHEMA_NAME</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.default_catalog</property>"
-msgstr "hibernate.default_catalog"
+msgstr "<property>hibernate.default_catalog</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Qualifies unqualified table names with the given catalog in generated SQL."
+msgid "Qualifies unqualified table names with the given catalog in generated SQL."
 msgstr "在生成的 SQL 中，将给定的 catalog é™„åŠ äºŽéžå…¨é™å®šåçš„è¡¨åä¸Šã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>CATALOG_NAME</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>CATALOG_NAME</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>CATALOG_NAME</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>CATALOG_NAME</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.session_factory_name</property>"
-msgstr "hibernate.session_factory_name"
+msgstr "<property>hibernate.session_factory_name</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"The <interfacename>org.hibernate.SessionFactory</interfacename> will be "
-"automatically bound to this name in JNDI after it has been created."
-msgstr ""
-"<interfacename>org.hibernate.SessionFactory</interfacename> 创建后，将自动使"
-"用这个名字绑定到 JNDI 中。"
+msgid "The <interfacename>org.hibernate.SessionFactory</interfacename> will be automatically bound to this name in JNDI after it has been created."
+msgstr "<interfacename>org.hibernate.SessionFactory</interfacename> 创建后，将自动使用这个名字绑定到 JNDI 中。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>jndi/composite/name</"
-"literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>jndi/composite/name</"
-"literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>jndi/composite/name</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>jndi/composite/name</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.max_fetch_depth</property>"
-msgstr "hibernate.max_fetch_depth"
+msgstr "<property>hibernate.max_fetch_depth</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Sets a maximum \"depth\" for the outer join fetch tree for single-ended "
-"associations (one-to-one, many-to-one). A <literal>0</literal> disables "
-"default outer join fetching."
-msgstr ""
-"为单向关联（一对一，多对一）的外连接抓取（outer join fetchï¼‰æ ‘è®¾ç½®æœ€å¤§æ·±åº¦ã€‚"
-"值为 <literal>0</literal> 意味着将关闭默认的外连接抓取。 "
+msgid "Sets a maximum \"depth\" for the outer join fetch tree for single-ended associations (one-to-one, many-to-one). A <literal>0</literal> disables default outer join fetching."
+msgstr "为单向关联（一对一，多对一）的外连接抓取（outer join fetchï¼‰æ ‘è®¾ç½®æœ€å¤§æ·±åº¦ã€‚å€¼ä¸º <literal>0</literal> 意味着将关闭默认的外连接抓取。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> recommended values between "
-"<literal>0</literal> and <literal>3</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis> 建议在 <literal>0</literal> 到 "
-"<literal>3</literal> 之间取值 "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> recommended values between <literal>0</literal> and <literal>3</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis> 建议在 <literal>0</literal> 到 <literal>3</literal> 之间取值 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.default_batch_fetch_size</property>"
-msgstr "hibernate.default_batch_fetch_size"
+msgstr "<property>hibernate.default_batch_fetch_size</property>"
 
 #. Tag: entry
 #, no-c-format
@@ -643,87 +416,63 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> recommended values <literal>4</"
-"literal>, <literal>8</literal>, <literal>16</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis>建议的取值为 <literal>4</"
-"literal>，<literal>8</literal>，和 <literal>16</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> recommended values <literal>4</literal>, <literal>8</literal>, <literal>16</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis>建议的取值为 <literal>4</literal>，<literal>8</literal>，和 <literal>16</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.default_entity_mode</property>"
-msgstr "hibernate.default_entity_mode"
+msgstr "<property>hibernate.default_entity_mode</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Sets a default mode for entity representation for all sessions opened from "
-"this <literal>SessionFactory</literal>"
-msgstr ""
-"为由这个 <literal>SessionFactory</literal> 打开的所有 Session 指定默认的实体"
-"表现模式。 "
+msgid "Sets a default mode for entity representation for all sessions opened from this <literal>SessionFactory</literal>"
+msgstr "为由这个 <literal>SessionFactory</literal> 打开的所有 Session 指定默认的实体表现模式。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</"
-"literal>"
-msgstr ""
-"<emphasis role=\"strong\">取值</emphasis><literal>dynamic-map</literal>，"
-"<literal>dom4j</literal>，<literal>pojo</literal>"
+msgid "<literal>dynamic-map</literal>, <literal>dom4j</literal>, <literal>pojo</literal>"
+msgstr "<emphasis role=\"strong\">取值</emphasis><literal>dynamic-map</literal>，<literal>dom4j</literal>，<literal>pojo</literal>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.order_updates</property>"
-msgstr "hibernate.order_updates"
+msgstr "<property>hibernate.order_updates</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Forces Hibernate to order SQL updates by the primary key value of the items "
-"being updated. This will result in fewer transaction deadlocks in highly "
-"concurrent systems."
-msgstr ""
-"强制 Hibernate 按照被更新数据的主键，为 SQL 更新排序。这么做将减少在高并发系"
-"统中事务的死锁。"
+msgid "Forces Hibernate to order SQL updates by the primary key value of the items being updated. This will result in fewer transaction deadlocks in highly concurrent systems."
+msgstr "强制 Hibernate 按照被更新数据的主键，为 SQL 更新排序。这么做将减少在高并发系统中事务的死锁。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.generate_statistics</property>"
-msgstr "hibernate.generate_statistics"
+msgstr "<property>hibernate.generate_statistics</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"If enabled, Hibernate will collect statistics useful for performance tuning."
+msgid "If enabled, Hibernate will collect statistics useful for performance tuning."
 msgstr "如果开启，Hibernate 将收集有助于性能调节的统计数据。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.use_identifier_rollback</property>"
-msgstr "hibernate.use_identifier_rollback"
+msgstr "<property>hibernate.use_identifier_rollback</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"If enabled, generated identifier properties will be reset to default values "
-"when objects are deleted."
+msgid "If enabled, generated identifier properties will be reset to default values when objects are deleted."
 msgstr "å¦‚æžœå¼€å¯ï¼Œåœ¨å¯¹è±¡è¢«åˆ é™¤æ—¶ç”Ÿæˆçš„æ ‡è¯†å±žæ€§å°†è¢«é‡è®¾ä¸ºé»˜è®¤å€¼ã€‚"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.use_sql_comments</property>"
-msgstr "hibernate.use_sql_comments"
+msgstr "<property>hibernate.use_sql_comments</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"If turned on, Hibernate will generate comments inside the SQL, for easier "
-"debugging, defaults to <literal>false</literal>."
-msgstr ""
-"如果开启，Hibernate 将在 SQL 中生成有助于调试的注释信息，默认值为 "
-"<literal>false</literal>。"
+msgid "If turned on, Hibernate will generate comments inside the SQL, for easier debugging, defaults to <literal>false</literal>."
+msgstr "如果开启，Hibernate 将在 SQL 中生成有助于调试的注释信息，默认值为 <literal>false</literal>。"
 
 #. Tag: title
 #, no-c-format
@@ -731,23 +480,19 @@
 msgstr "Hibernate JDBC 和连接（connection）属性"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.fetch_size</property>"
-msgstr "hibernate.jdbc.fetch_size"
+msgstr "<property>hibernate.jdbc.fetch_size</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"A non-zero value determines the JDBC fetch size (calls <literal>Statement."
-"setFetchSize()</literal>)."
-msgstr ""
-"非零值，指定 JDBC 抓取数量的大小（调用 <literal>Statement.setFetchSize()</"
-"literal>）。"
+msgid "A non-zero value determines the JDBC fetch size (calls <literal>Statement.setFetchSize()</literal>)."
+msgstr "非零值，指定 JDBC 抓取数量的大小（调用 <literal>Statement.setFetchSize()</literal>）。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.batch_size</property>"
-msgstr "hibernate.jdbc.batch_size"
+msgstr "<property>hibernate.jdbc.batch_size</property>"
 
 #. Tag: entry
 #, no-c-format
@@ -756,159 +501,103 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> recommended values between "
-"<literal>5</literal> and <literal>30</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis>建议取 <literal>5</literal> 到 "
-"<literal>30</literal> 之间的值 "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> recommended values between <literal>5</literal> and <literal>30</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis>建议取 <literal>5</literal> 到 <literal>30</literal> 之间的值 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.batch_versioned_data</property>"
-msgstr "hibernate.jdbc.batch_versioned_data"
+msgstr "<property>hibernate.jdbc.batch_versioned_data</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Set this property to <literal>true</literal> if your JDBC driver returns "
-"correct row counts from <literal>executeBatch()</literal>. Iit is usually "
-"safe to turn this option on. Hibernate will then use batched DML for "
-"automatically versioned data. Defaults to <literal>false</literal>."
-msgstr ""
-"å¦‚æžœä½ æƒ³è®©ä½ çš„ JDBC 驱动从 <literal>true</literal> 返回正确的行计数 ，那么将"
-"此属性设为 <literal>executeBatch()</literal>（开启这个选项通常是安全的）。同"
-"时，Hibernate 将为自动版本化的数据使用批量 DML。默认值为 <literal>false</"
-"literal>。 "
+msgid "Set this property to <literal>true</literal> if your JDBC driver returns correct row counts from <literal>executeBatch()</literal>. Iit is usually safe to turn this option on. Hibernate will then use batched DML for automatically versioned data. Defaults to <literal>false</literal>."
+msgstr "å¦‚æžœä½ æƒ³è®©ä½ çš„ JDBC 驱动从 <literal>true</literal> 返回正确的行计数 ，那么将此属性设为 <literal>executeBatch()</literal>（开启这个选项通常是安全的）。同时，Hibernate 将为自动版本化的数据使用批量 DML。默认值为 <literal>false</literal>。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.factory_class</property>"
-msgstr "hibernate.jdbc.factory_class"
+msgstr "<property>hibernate.jdbc.factory_class</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Select a custom <interfacename>org.hibernate.jdbc.Batcher</interfacename>. "
-"Most applications will not need this configuration property."
-msgstr ""
-"选择一个自定义的 <literal>Batcher</literal>。多数应用程序不需要这个配置属"
-"性。 "
+msgid "Select a custom <interfacename>org.hibernate.jdbc.Batcher</interfacename>. Most applications will not need this configuration property."
+msgstr "选择一个自定义的 <literal>Batcher</literal>。多数应用程序不需要这个配置属性。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of."
-"BatcherFactory</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.Batcher</"
-"literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.BatcherFactory</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.Batcher</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.use_scrollable_resultset</property>"
-msgstr "hibernate.jdbc.use_scrollable_resultset"
+msgstr "<property>hibernate.jdbc.use_scrollable_resultset</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Enables use of JDBC2 scrollable resultsets by Hibernate. This property is "
-"only necessary when using user-supplied JDBC connections. Hibernate uses "
-"connection metadata otherwise."
-msgstr ""
-"允许 Hibernate 使用 JDBC2 的可滚动结果集。只有在使用用户提供的 JDBC 连接时，"
-"这个选项才是必要的，否则 Hibernate 会使用连接的元数据。 "
+msgid "Enables use of JDBC2 scrollable resultsets by Hibernate. This property is only necessary when using user-supplied JDBC connections. Hibernate uses connection metadata otherwise."
+msgstr "允许 Hibernate 使用 JDBC2 的可滚动结果集。只有在使用用户提供的 JDBC 连接时，这个选项才是必要的，否则 Hibernate 会使用连接的元数据。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.use_streams_for_binary</property>"
-msgstr "hibernate.jdbc.use_streams_for_binary"
+msgstr "<property>hibernate.jdbc.use_streams_for_binary</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Use streams when writing/reading <literal>binary</literal> or "
-"<literal>serializable</literal> types to/from JDBC. <emphasis>*system-level "
-"property*</emphasis>"
-msgstr ""
-"在 JDBC 读写 <literal>binary</literal> 或 <literal>serializable</literal> 的"
-"类型时使用流（stream）（系统级属性）。 "
+msgid "Use streams when writing/reading <literal>binary</literal> or <literal>serializable</literal> types to/from JDBC. <emphasis>*system-level property*</emphasis>"
+msgstr "在 JDBC 读写 <literal>binary</literal> 或 <literal>serializable</literal> 的类型时使用流（stream）（系统级属性）。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.jdbc.use_get_generated_keys</property>"
-msgstr "hibernate.jdbc.use_get_generated_keys"
+msgstr "<property>hibernate.jdbc.use_get_generated_keys</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Enables use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> "
-"to retrieve natively generated keys after insert. Requires JDBC3+ driver and "
-"JRE1.4+, set to false if your driver has problems with the Hibernate "
-"identifier generators. By default, it tries to determine the driver "
-"capabilities using connection metadata."
-msgstr ""
-"在数据插入数据库之后，允许使用 JDBC3 <literal>PreparedStatement."
-"getGeneratedKeys()</literal> 来获取数据库生成的 key（键）。需要 JDBC3+ 驱动"
-"å’Œ JRE1.4+ï¼Œå¦‚æžœä½ çš„æ•°æ®åº“é©±åŠ¨åœ¨ä½¿ç”¨ Hibernate çš„æ ‡è¯†ç”Ÿæˆå™¨æ—¶é‡åˆ°é—®é¢˜ï¼Œè¯·å°†æ­¤"
-"值设为 false。默认情况下将使用连接的元数据来判定驱动的能力。 "
+msgid "Enables use of JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> to retrieve natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+, set to false if your driver has problems with the Hibernate identifier generators. By default, it tries to determine the driver capabilities using connection metadata."
+msgstr "在数据插入数据库之后，允许使用 JDBC3 <literal>PreparedStatement.getGeneratedKeys()</literal> 来获取数据库生成的 key（键）。需要 JDBC3+ 驱动和 JRE1.4+ï¼Œå¦‚æžœä½ çš„æ•°æ®åº“é©±åŠ¨åœ¨ä½¿ç”¨ Hibernate çš„æ ‡è¯†ç”Ÿæˆå™¨æ—¶é‡åˆ°é—®é¢˜ï¼Œè¯·å°†æ­¤å€¼è®¾ä¸º false。默认情况下将使用连接的元数据来判定驱动的能力。 "
 
 #. Tag: para
 #, no-c-format
 msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>true|false</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>true | false</literal> "
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>true | false</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.provider_class</property>"
-msgstr "hibernate.connection.provider_class"
+msgstr "<property>hibernate.connection.provider_class</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"The classname of a custom <interfacename>org.hibernate.connection."
-"ConnectionProvider</interfacename> which provides JDBC connections to "
-"Hibernate."
-msgstr ""
-"自定义 <literal>ConnectionProvider</literal> 的类名，此类用来向 Hibernate 提"
-"供 JDBC 连接。 "
+msgid "The classname of a custom <interfacename>org.hibernate.connection.ConnectionProvider</interfacename> which provides JDBC connections to Hibernate."
+msgstr "自定义 <literal>ConnectionProvider</literal> 的类名，此类用来向 Hibernate 提供 JDBC 连接。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of."
-"ConnectionProvider</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>classname.of."
-"ConnectionProvider</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.ConnectionProvider</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.ConnectionProvider</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.isolation</property>"
-msgstr "hibernate.connection.isolation"
+msgstr "<property>hibernate.connection.isolation</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Sets the JDBC transaction isolation level. Check <interfacename>java.sql."
-"Connection</interfacename> for meaningful values, but note that most "
-"databases do not support all isolation levels and some define additional, "
-"non-standard isolations."
-msgstr ""
-"设置 JDBC 事务隔离级别。查看 <literal>java.sql.Connection</literal> 来了解各"
-"个值的具体意义，但请注意多数数据库都不支持所有的隔离级别。 "
+msgid "Sets the JDBC transaction isolation level. Check <interfacename>java.sql.Connection</interfacename> for meaningful values, but note that most databases do not support all isolation levels and some define additional, non-standard isolations."
+msgstr "设置 JDBC 事务隔离级别。查看 <literal>java.sql.Connection</literal> 来了解各个值的具体意义，但请注意多数数据库都不支持所有的隔离级别。 "
 
 #. Tag: para
 #, no-c-format
 msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>1, 2, 4, 8</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>1, 2, 4, 8</literal> "
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>1, 2, 4, 8</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.autocommit</property>"
-msgstr "hibernate.connection.autocommit"
+msgstr "<property>hibernate.connection.autocommit</property>"
 
 #. Tag: entry
 #, no-c-format
@@ -916,92 +605,44 @@
 msgstr "允许被缓存的 JDBC 连接开启自动提交（autocommit）（不推荐）。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<property>hibernate.connection.release_mode</property>"
-msgstr "hibernate.connection.release_mode"
+msgstr "<property>hibernate.connection.release_mode</property>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Specifies when Hibernate should release JDBC connections. By default, a JDBC "
-"connection is held until the session is explicitly closed or disconnected. "
-"For an application server JTA datasource, use <literal>after_statement</"
-"literal> to aggressively release connections after every JDBC call. For a "
-"non-JTA connection, it often makes sense to release the connection at the "
-"end of each transaction, by using <literal>after_transaction</literal>. "
-"<literal>auto</literal> will choose <literal>after_statement</literal> for "
-"the JTA and CMT transaction strategies and <literal>after_transaction</"
-"literal> for the JDBC transaction strategy."
-msgstr ""
-"指定 Hibernate 在何时释放 JDBC 连接。默认情况下,直到 Session 被显式关闭或被断"
-"开连接时,才会释放 JDBC 连接。对于应用程序服务器的 JTA æ•°æ®æºï¼Œä½ åº”å½“ä½¿ç”¨  "
-"<literal>after_statement</literal>ï¼Œè¿™æ ·åœ¨æ¯æ¬¡ JDBC 调用后，都会主动的释放连"
-"接。对于非 JTA 的连接，使用 <literal>after_transaction</literal> 在每个事务结"
-"束时释放连接是合理的。<literal>auto</literal> 将为 JTA 和 CMT 事务策略选择 "
-"<literal>after_statement</literal>，为JDBC事务策略选择 "
-"<literal>after_transaction</literal>。"
+msgid "Specifies when Hibernate should release JDBC connections. By default, a JDBC connection is held until the session is explicitly closed or disconnected. For an application server JTA datasource, use <literal>after_statement</literal> to aggressively release connections after every JDBC call. For a non-JTA connection, it often makes sense to release the connection at the end of each transaction, by using <literal>after_transaction</literal>. <literal>auto</literal> will choose <literal>after_statement</literal> for the JTA and CMT transaction strategies and <literal>after_transaction</literal> for the JDBC transaction strategy."
+msgstr "指定 Hibernate 在何时释放 JDBC 连接。默认情况下,直到 Session 被显式关闭或被断开连接时,才会释放 JDBC 连接。对于应用程序服务器的 JTA æ•°æ®æºï¼Œä½ åº”å½“ä½¿ç”¨  <literal>after_statement</literal>ï¼Œè¿™æ ·åœ¨æ¯æ¬¡ JDBC 调用后，都会主动的释放连接。对于非 JTA 的连接，使用 <literal>after_transaction</literal> 在每个事务结束时释放连接是合理的。<literal>auto</literal> 将为 JTA å’Œ CMT 事务策略选择 <literal>after_statement</literal>，为JDBC事务策略选择 <literal>after_transaction</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>auto</literal> (default) "
-"| <literal>on_close</literal> | <literal>after_transaction</literal> | "
-"<literal>after_statement</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>auto</literal> (默认) | "
-"<literal>on_close</literal> | <literal>after_transaction</literal> | "
-"<literal>after_statement</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>auto</literal> (default) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>auto</literal> (默认) | <literal>on_close</literal> | <literal>after_transaction</literal> | <literal>after_statement</literal> "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This setting only affects <literal>Session</literal>s returned from "
-"<literal>SessionFactory.openSession</literal>. For <literal>Session</"
-"literal>s obtained through <literal>SessionFactory.getCurrentSession</"
-"literal>, the <literal>CurrentSessionContext</literal> implementation "
-"configured for use controls the connection release mode for those "
-"<literal>Session</literal>s. See <xref linkend=\"architecture-current-session"
-"\" />"
-msgstr ""
-"注意，这些设置仅对通过 <literal>SessionFactory.openSession</literal> 得到的 "
-"<literal>Session</literal> 起作用。对于通过 <literal>SessionFactory."
-"getCurrentSession</literal> 得到的 <literal>Session</literal>，所配置的 "
-"<literal>CurrentSessionContext</literal> 实现控制这些 <literal>Session</"
-"literal> 的连接释放模式。请参阅"
+#, no-c-format
+msgid "This setting only affects <literal>Session</literal>s returned from <literal>SessionFactory.openSession</literal>. For <literal>Session</literal>s obtained through <literal>SessionFactory.getCurrentSession</literal>, the <literal>CurrentSessionContext</literal> implementation configured for use controls the connection release mode for those <literal>Session</literal>s. See <xref linkend=\"architecture-current-session\" />"
+msgstr "注意，这些设置仅对通过 <literal>SessionFactory.openSession</literal> 得到的 <literal>Session</literal> 起作用。对于通过 <literal>SessionFactory.getCurrentSession</literal> 得到的 <literal>Session</literal>，所配置的 <literal>CurrentSessionContext</literal> 实现控制这些 <literal>Session</literal> 的连接释放模式。请参阅 <xref linkend=\"architecture-current-session\" />。 "
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"<property>hibernate.connection.</property><emphasis>&lt;propertyName&gt;</"
-"emphasis>"
-msgstr ""
-"<property>hibernate.connection.</property><emphasis>&lt;propertyName&gt;</"
-"emphasis>"
+msgid "<property>hibernate.connection.</property><emphasis>&lt;propertyName&gt;</emphasis>"
+msgstr "<property>hibernate.connection.</property><emphasis>&lt;propertyName&gt;</emphasis>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Pass the JDBC property <emphasis>&lt;propertyName&gt;</emphasis> to "
-"<literal>DriverManager.getConnection()</literal>."
-msgstr ""
-"把 JDBC 属性 <emphasis>&lt;propertyName&gt;</emphasis> ä¼ é€’ç»™ "
-"<literal>DriverManager.getConnection()</literal>。"
+msgid "Pass the JDBC property <emphasis>&lt;propertyName&gt;</emphasis> to <literal>DriverManager.getConnection()</literal>."
+msgstr "把 JDBC 属性 <emphasis>&lt;propertyName&gt;</emphasis> ä¼ é€’ç»™ <literal>DriverManager.getConnection()</literal>。"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"<property>hibernate.jndi.</property><emphasis>&lt;propertyName&gt;</emphasis>"
-msgstr ""
-"<property>hibernate.jndi.</property><emphasis>&lt;propertyName&gt;</emphasis>"
+msgid "<property>hibernate.jndi.</property><emphasis>&lt;propertyName&gt;</emphasis>"
+msgstr "<property>hibernate.jndi.</property><emphasis>&lt;propertyName&gt;</emphasis>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Pass the property <emphasis>&lt;propertyName&gt;</emphasis> to the JNDI "
-"<literal>InitialContextFactory</literal>."
-msgstr ""
-"把 <emphasis>&lt;propertyName&gt;</emphasis> å±žæ€§ä¼ é€’ç»™ JNDI "
-"<literal>InitialContextFactory</literal>。"
+msgid "Pass the property <emphasis>&lt;propertyName&gt;</emphasis> to the JNDI <literal>InitialContextFactory</literal>."
+msgstr "把 <emphasis>&lt;propertyName&gt;</emphasis> å±žæ€§ä¼ é€’ç»™ JNDI <literal>InitialContextFactory</literal>。"
 
 #. Tag: title
 #, no-c-format
@@ -1009,9 +650,9 @@
 msgstr "Hibernate 缓存属性"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.provider_class</literal>"
-msgstr "hibernate.cache.provider_class"
+msgstr "<literal>hibernate.cache.provider_class</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1020,81 +661,58 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of."
-"CacheProvider</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>classname.of."
-"CacheProvider</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.CacheProvider</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.CacheProvider</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.use_minimal_puts</literal>"
-msgstr "hibernate.cache.use_minimal_puts"
+msgstr "<literal>hibernate.cache.use_minimal_puts</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Optimizes second-level cache operation to minimize writes, at the cost of "
-"more frequent reads. This setting is most useful for clustered caches and, "
-"in Hibernate3, is enabled by default for clustered cache implementations."
-msgstr ""
-"以频繁的读操作为代价，优化二级缓存来最小化写操作。在 Hibernate3 中，这个设置"
-"对的集群缓存非常有用，对集群缓存的实现而言，默认是开启的。 "
+msgid "Optimizes second-level cache operation to minimize writes, at the cost of more frequent reads. This setting is most useful for clustered caches and, in Hibernate3, is enabled by default for clustered cache implementations."
+msgstr "以频繁的读操作为代价，优化二级缓存来最小化写操作。在 Hibernate3 中，这个设置对的集群缓存非常有用，对集群缓存的实现而言，默认是开启的。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.use_query_cache</literal>"
-msgstr "hibernate.cache.use_query_cache"
+msgstr "<literal>hibernate.cache.use_query_cache</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Enables the query cache. Individual queries still have to be set cachable."
+msgid "Enables the query cache. Individual queries still have to be set cachable."
 msgstr "允许查询缓存，个别查询仍然需要被设置为可缓存的。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.use_second_level_cache</literal>"
-msgstr "hibernate.cache.use_second_level_cache"
+msgstr "<literal>hibernate.cache.use_second_level_cache</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Can be used to completely disable the second level cache, which is enabled "
-"by default for classes which specify a <literal>&lt;cache&gt;</literal> "
-"mapping."
-msgstr ""
-"èƒ½ç”¨æ¥å®Œå…¨ç¦æ­¢ä½¿ç”¨äºŒçº§ç¼“å­˜ã€‚å¯¹é‚£äº›åœ¨ç±»çš„æ˜ å°„å®šä¹‰ä¸­æŒ‡å®š <literal>&lt;cache&gt;"
-"</literal> 的类，会默认开启二级缓存。 "
+msgid "Can be used to completely disable the second level cache, which is enabled by default for classes which specify a <literal>&lt;cache&gt;</literal> mapping."
+msgstr "èƒ½ç”¨æ¥å®Œå…¨ç¦æ­¢ä½¿ç”¨äºŒçº§ç¼“å­˜ã€‚å¯¹é‚£äº›åœ¨ç±»çš„æ˜ å°„å®šä¹‰ä¸­æŒ‡å®š <literal>&lt;cache&gt;</literal> 的类，会默认开启二级缓存。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.query_cache_factory</literal>"
-msgstr "hibernate.cache.query_cache_factory"
+msgstr "<literal>hibernate.cache.query_cache_factory</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"The classname of a custom <literal>QueryCache</literal> interface, defaults "
-"to the built-in <literal>StandardQueryCache</literal>."
-msgstr ""
-"自定义实现 <literal>QueryCache</literal> 接口的类名，默认为内建的 "
-"<literal>StandardQueryCache</literal>。"
+msgid "The classname of a custom <literal>QueryCache</literal> interface, defaults to the built-in <literal>StandardQueryCache</literal>."
+msgstr "自定义实现 <literal>QueryCache</literal> 接口的类名，默认为内建的 <literal>StandardQueryCache</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.QueryCache</"
-"literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.QueryCache</"
-"literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.QueryCache</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.QueryCache</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.region_prefix</literal>"
-msgstr "hibernate.cache.region_prefix"
+msgstr "<literal>hibernate.cache.region_prefix</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1107,15 +725,13 @@
 msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>prefix</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cache.use_structured_entries</literal>"
-msgstr "hibernate.cache.use_structured_entries"
+msgstr "<literal>hibernate.cache.use_structured_entries</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Forces Hibernate to store data in the second-level cache in a more human-"
-"friendly format."
+msgid "Forces Hibernate to store data in the second-level cache in a more human-friendly format."
 msgstr "强制 Hibernate ä»¥æ›´äººæ€§åŒ–çš„æ ¼å¼å°†æ•°æ®å­˜å…¥äºŒçº§ç¼“å­˜ã€‚"
 
 #. Tag: title
@@ -1124,101 +740,64 @@
 msgstr "Hibernate 事务属性"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.transaction.factory_class</literal>"
-msgstr "hibernate.transaction.factory_class"
+msgstr "<literal>hibernate.transaction.factory_class</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"The classname of a <literal>TransactionFactory</literal> to use with "
-"Hibernate <literal>Transaction</literal> API (defaults to "
-"<literal>JDBCTransactionFactory</literal>)."
-msgstr ""
-"一个 <literal>TransactionFactory</literal> 的类名，用于 Hibernate "
-"<literal>Transaction</literal> API（默认为 <literal>JDBCTransactionFactory</"
-"literal>）。"
+msgid "The classname of a <literal>TransactionFactory</literal> to use with Hibernate <literal>Transaction</literal> API (defaults to <literal>JDBCTransactionFactory</literal>)."
+msgstr "一个 <literal>TransactionFactory</literal> 的类名，用于 Hibernate <literal>Transaction</literal> API（默认为 <literal>JDBCTransactionFactory</literal>）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of."
-"TransactionFactory</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>classname.of."
-"TransactionFactory</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.TransactionFactory</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.TransactionFactory</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>jta.UserTransaction</literal>"
-msgstr "jta.UserTransaction"
+msgstr "<literal>jta.UserTransaction</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the "
-"JTA <literal>UserTransaction</literal> from the application server."
-msgstr ""
-"一个 JNDI 名字，被 <literal>JTATransactionFactory</literal> 用来从应用服务器"
-"获取 JTA   <literal>UserTransaction</literal>。"
+msgid "A JNDI name used by <literal>JTATransactionFactory</literal> to obtain the JTA <literal>UserTransaction</literal> from the application server."
+msgstr "一个 JNDI 名字，被 <literal>JTATransactionFactory</literal> 用来从应用服务器获取 JTA   <literal>UserTransaction</literal>。"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.transaction. manager_lookup_class</literal>"
-msgstr "hibernate.transaction.manager_lookup_class"
+msgstr "<literal>hibernate.transaction. manager_lookup_class</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"The classname of a <literal>TransactionManagerLookup</literal>. It is "
-"required when JVM-level caching is enabled or when using hilo generator in a "
-"JTA environment."
-msgstr ""
-"一个 <literal>TransactionManagerLookup</literal> 的类名 — 当使用 JVM 级缓存，"
-"或在 JTA 环境中使用 hilo 生成器的时候需要该类。 "
+msgid "The classname of a <literal>TransactionManagerLookup</literal>. It is required when JVM-level caching is enabled or when using hilo generator in a JTA environment."
+msgstr "一个 <literal>TransactionManagerLookup</literal> 的类名 — 当使用 JVM 级缓存，或在 JTA 环境中使用 hilo 生成器的时候需要该类。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of."
-"TransactionManagerLookup</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>classname.of."
-"TransactionManagerLookup</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>classname.of.TransactionManagerLookup</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>classname.of.TransactionManagerLookup</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.transaction. flush_before_completion</literal>"
-msgstr "hibernate.transaction.flush_before_completion"
+msgstr "<literal>hibernate.transaction. flush_before_completion</literal>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"If enabled, the session will be automatically flushed during the before "
-"completion phase of the transaction. Built-in and automatic session context "
-"management is preferred, see <xref linkend=\"architecture-current-session\" /"
-">."
-msgstr ""
-"如果开启，session 在事务完成后将被自动清洗（flush）。现在更好的方法是使用自"
-"动 session 上下文管理。请参见 <xref linkend=\"architecture-current-session\"/"
-">。"
+#, no-c-format
+msgid "If enabled, the session will be automatically flushed during the before completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\" />."
+msgstr "如果开启，session 在事务完成后将被自动清洗（flush）。现在更好的方法是使用自动 session 上下文管理。请参见 <xref linkend=\"architecture-current-session\"/>。 "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.transaction. auto_close_session</literal>"
-msgstr "hibernate.transaction.auto_close_session"
+msgstr "<literal>hibernate.transaction. auto_close_session</literal>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"If enabled, the session will be automatically closed during the after "
-"completion phase of the transaction. Built-in and automatic session context "
-"management is preferred, see <xref linkend=\"architecture-current-session\" /"
-">."
-msgstr ""
-"如果开启，session 在事务完成后将被自动关闭。 现在更好的方法是使用自动 "
-"session 上下文管理。请参见 <xref linkend=\"architecture-current-session\"/"
-">。 "
+#, no-c-format
+msgid "If enabled, the session will be automatically closed during the after completion phase of the transaction. Built-in and automatic session context management is preferred, see <xref linkend=\"architecture-current-session\" />."
+msgstr "如果开启，session 在事务完成后将被自动关闭。 现在更好的方法是使用自动 session 上下文管理。请参见 <xref linkend=\"architecture-current-session\"/>。  "
 
 #. Tag: title
 #, no-c-format
@@ -1226,35 +805,24 @@
 msgstr "其他属性"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate. current_session_context_class</literal>"
-msgstr "hibernate.current_session_context_class"
+msgstr "<literal>hibernate. current_session_context_class</literal>"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"Supply a custom strategy for the scoping of the \"current\" "
-"<literal>Session</literal>. See <xref linkend=\"architecture-current-session"
-"\" /> for more information about the built-in strategies."
-msgstr ""
-"为\"当前\" <literal>Session</literal> 指定一个（自定义的）策略。关于内置策略"
-"的详情，请参见 <xref linkend=\"architecture-current-session\"/>。"
+#, no-c-format
+msgid "Supply a custom strategy for the scoping of the \"current\" <literal>Session</literal>. See <xref linkend=\"architecture-current-session\" /> for more information about the built-in strategies."
+msgstr "为\"当前\" <literal>Session</literal> 指定一个（自定义的）策略。关于内置策略的详情，请参见 <xref linkend=\"architecture-current-session\"/>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>jta</literal> | "
-"<literal>thread</literal> | <literal>managed</literal> | <literal>custom."
-"Class</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>jta</literal> | "
-"<literal>thread</literal> | <literal>managed</literal> | <literal>custom."
-"Class</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>jta</literal> | <literal>thread</literal> | <literal>managed</literal> | <literal>custom.Class</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.query.factory_class</literal>"
-msgstr "hibernate.query.factory_class"
+msgstr "<literal>hibernate.query.factory_class</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1263,82 +831,48 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>org.hibernate.hql.ast."
-"ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic."
-"ClassicQueryTranslatorFactory</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>org.hibernate.hql.ast."
-"ASTQueryTranslatorFactory</literal> 或 <literal>org.hibernate.hql.classic."
-"ClassicQueryTranslatorFactory</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> or <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>org.hibernate.hql.ast.ASTQueryTranslatorFactory</literal> 或 <literal>org.hibernate.hql.classic.ClassicQueryTranslatorFactory</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.query.substitutions</literal>"
-msgstr "hibernate.query.substitutions"
+msgstr "<literal>hibernate.query.substitutions</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Is used to map from tokens in Hibernate queries to SQL tokens (tokens might "
-"be function or literal names, for example)."
-msgstr ""
-"å°† Hibernate æŸ¥è¯¢ä¸­çš„ç¬¦å·æ˜ å°„åˆ° SQL 查询中的符号（符号可能是函数名或常量名"
-"字）。  "
+msgid "Is used to map from tokens in Hibernate queries to SQL tokens (tokens might be function or literal names, for example)."
+msgstr "å°† Hibernate æŸ¥è¯¢ä¸­çš„ç¬¦å·æ˜ å°„åˆ° SQL 查询中的符号（符号可能是函数名或常量名字）。  "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>hqlLiteral=SQL_LITERAL, "
-"hqlFunction=SQLFUNC</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>hqlLiteral=SQL_LITERAL, "
-"hqlFunction=SQLFUNC</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>hqlLiteral=SQL_LITERAL, hqlFunction=SQLFUNC</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.hbm2ddl.auto</literal>"
-msgstr "hibernate.hbm2ddl.auto"
+msgstr "<literal>hibernate.hbm2ddl.auto</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Automatically validates or exports schema DDL to the database when the "
-"<literal>SessionFactory</literal> is created. With <literal>create-drop</"
-"literal>, the database schema will be dropped when the "
-"<literal>SessionFactory</literal> is closed explicitly."
-msgstr ""
-"在 <literal>SessionFactory</literal> 创建时，自动检查数据库结构，或者将数据"
-"库 schema 的 DDL 导出到数据库。使用 <literal>create-drop</literal> 时，在显式"
-"关闭 <literal>SessionFactory</literal> æ—¶ï¼Œå°†åˆ é™¤æŽ‰æ•°æ®åº“ schema。 "
+msgid "Automatically validates or exports schema DDL to the database when the <literal>SessionFactory</literal> is created. With <literal>create-drop</literal>, the database schema will be dropped when the <literal>SessionFactory</literal> is closed explicitly."
+msgstr "在 <literal>SessionFactory</literal> 创建时，自动检查数据库结构，或者将数据库 schema çš„ DDL 导出到数据库。使用 <literal>create-drop</literal> 时，在显式关闭 <literal>SessionFactory</literal> æ—¶ï¼Œå°†åˆ é™¤æŽ‰æ•°æ®åº“ schema。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis role=\"strong\">e.g.</emphasis> <literal>validate</literal> | "
-"<literal>update</literal> | <literal>create</literal> | <literal>create-"
-"drop</literal>"
-msgstr ""
-"<emphasis role=\"strong\">例如：</emphasis><literal>validate</literal> | "
-"<literal>update</literal> | <literal>create</literal> | <literal>create-"
-"drop</literal> "
+msgid "<emphasis role=\"strong\">e.g.</emphasis> <literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal>"
+msgstr "<emphasis role=\"strong\">例如：</emphasis><literal>validate</literal> | <literal>update</literal> | <literal>create</literal> | <literal>create-drop</literal> "
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>hibernate.cglib. use_reflection_optimizer</literal>"
-msgstr "hibernate.cglib.use_reflection_optimizer"
+msgstr "<literal>hibernate.cglib. use_reflection_optimizer</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Enables the use of CGLIB instead of runtime reflection (System-level "
-"property). Reflection can sometimes be useful when troubleshooting. "
-"Hibernate always requires CGLIB even if you turn off the optimizer. You "
-"cannot set this property in <literal>hibernate.cfg.xml</literal>."
-msgstr ""
-"开启 CGLIB 来替代运行时反射机制（系统级属性）。反射机制有时在除错时比较有用。"
-"注意即使关闭这个优化，Hibernate 还是需要 CGLIBã€‚ä½ ä¸èƒ½åœ¨ <literal>hibernate."
-"cfg.xml</literal> 中设置此属性。 "
+msgid "Enables the use of CGLIB instead of runtime reflection (System-level property). Reflection can sometimes be useful when troubleshooting. Hibernate always requires CGLIB even if you turn off the optimizer. You cannot set this property in <literal>hibernate.cfg.xml</literal>."
+msgstr "开启 CGLIB 来替代运行时反射机制（系统级属性）。反射机制有时在除错时比较有用。注意即使关闭这个优化，Hibernate 还是需要 CGLIBã€‚ä½ ä¸èƒ½åœ¨ <literal>hibernate.cfg.xml</literal> 中设置此属性。 "
 
 #. Tag: title
 #, no-c-format
@@ -1347,17 +881,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Always set the <literal>hibernate.dialect</literal> property to the correct "
-"<literal>org.hibernate.dialect.Dialect</literal> subclass for your database. "
-"If you specify a dialect, Hibernate will use sensible defaults for some of "
-"the other properties listed above. This means that you will not have to "
-"specify them manually."
-msgstr ""
-"ä½ åº”å½“æ€»æ˜¯ä¸ºä½ çš„æ•°æ®åº“å°† <literal>hibernate.dialect</literal> 属性设置成正确"
-"çš„  <literal>org.hibernate.dialect.Dialect</literal> å­ç±»ã€‚å¦‚æžœä½ æŒ‡å®šä¸€ç§æ–¹"
-"言，Hibernate å°†ä¸ºä¸Šé¢åˆ—å‡ºçš„ä¸€äº›å±žæ€§ä½¿ç”¨åˆç†çš„é»˜è®¤å€¼ï¼Œè¿™æ ·ä½ å°±ä¸ç”¨æ‰‹å·¥æŒ‡å®šå®ƒ"
-"们。"
+msgid "Always set the <literal>hibernate.dialect</literal> property to the correct <literal>org.hibernate.dialect.Dialect</literal> subclass for your database. If you specify a dialect, Hibernate will use sensible defaults for some of the other properties listed above. This means that you will not have to specify them manually."
+msgstr "ä½ åº”å½“æ€»æ˜¯ä¸ºä½ çš„æ•°æ®åº“å°† <literal>hibernate.dialect</literal> 属性设置成正确的  <literal>org.hibernate.dialect.Dialect</literal> å­ç±»ã€‚å¦‚æžœä½ æŒ‡å®šä¸€ç§æ–¹è¨€ï¼ŒHibernate å°†ä¸ºä¸Šé¢åˆ—å‡ºçš„ä¸€äº›å±žæ€§ä½¿ç”¨åˆç†çš„é»˜è®¤å€¼ï¼Œè¿™æ ·ä½ å°±ä¸ç”¨æ‰‹å·¥æŒ‡å®šå®ƒä»¬ã€‚"
 
 #. Tag: title
 #, no-c-format
@@ -1377,12 +902,12 @@
 #. Tag: entry
 #, no-c-format
 msgid "DB2"
-msgstr ""
+msgstr "DB2"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.DB2Dialect</literal>"
-msgstr "org.hibernate.dialect.DB2Dialect"
+msgstr "<literal>org.hibernate.dialect.DB2Dialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1390,9 +915,9 @@
 msgstr "DB2 AS/400"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.DB2400Dialect</literal>"
-msgstr "org.hibernate.dialect.DB2400Dialect"
+msgstr "<literal>org.hibernate.dialect.DB2400Dialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1400,9 +925,9 @@
 msgstr "DB2 OS390"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.DB2390Dialect</literal>"
-msgstr "org.hibernate.dialect.DB2390Dialect"
+msgstr "<literal>org.hibernate.dialect.DB2390Dialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1410,9 +935,9 @@
 msgstr "PostgreSQL"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.PostgreSQLDialect</literal>"
-msgstr "org.hibernate.dialect.PostgreSQLDialect"
+msgstr "<literal>org.hibernate.dialect.PostgreSQLDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1420,9 +945,9 @@
 msgstr "MySQL"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.MySQLDialect</literal>"
-msgstr "org.hibernate.dialect.MySQLDialect"
+msgstr "<literal>org.hibernate.dialect.MySQLDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1430,9 +955,9 @@
 msgstr "MySQL with InnoDB"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.MySQLInnoDBDialect</literal>"
-msgstr "org.hibernate.dialect.MySQLInnoDBDialect"
+msgstr "<literal>org.hibernate.dialect.MySQLInnoDBDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1440,9 +965,9 @@
 msgstr "MySQL with MyISAM"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.MySQLMyISAMDialect</literal>"
-msgstr "org.hibernate.dialect.MySQLMyISAMDialect"
+msgstr "<literal>org.hibernate.dialect.MySQLMyISAMDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1450,9 +975,9 @@
 msgstr "Oracle（any version）"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.OracleDialect</literal>"
-msgstr "org.hibernate.dialect.OracleDialect"
+msgstr "<literal>org.hibernate.dialect.OracleDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1460,9 +985,9 @@
 msgstr "Oracle 9i"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.Oracle9iDialect</literal>"
-msgstr "org.hibernate.dialect.Oracle9iDialect"
+msgstr "<literal>org.hibernate.dialect.Oracle9iDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1470,9 +995,9 @@
 msgstr "Oracle 10g"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.Oracle10gDialect</literal>"
-msgstr "org.hibernate.dialect.Oracle10gDialect"
+msgstr "<literal>org.hibernate.dialect.Oracle10gDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1480,9 +1005,9 @@
 msgstr "Sybase"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.SybaseDialect</literal>"
-msgstr "org.hibernate.dialect.SybaseDialect"
+msgstr "<literal>org.hibernate.dialect.SybaseDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1490,9 +1015,9 @@
 msgstr "Sybase Anywhere"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.SybaseAnywhereDialect</literal>"
-msgstr "org.hibernate.dialect.SybaseAnywhereDialect"
+msgstr "<literal>org.hibernate.dialect.SybaseAnywhereDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1500,9 +1025,9 @@
 msgstr "Microsoft SQL Server"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.SQLServerDialect</literal>"
-msgstr "org.hibernate.dialect.SQLServerDialect"
+msgstr "<literal>org.hibernate.dialect.SQLServerDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1510,9 +1035,9 @@
 msgstr "SAP DB"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.SAPDBDialect</literal>"
-msgstr "org.hibernate.dialect.SAPDBDialect"
+msgstr "<literal>org.hibernate.dialect.SAPDBDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1520,9 +1045,9 @@
 msgstr "Informix"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.InformixDialect</literal>"
-msgstr "org.hibernate.dialect.InformixDialect"
+msgstr "<literal>org.hibernate.dialect.InformixDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1530,9 +1055,9 @@
 msgstr "HypersonicSQL"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.HSQLDialect</literal>"
-msgstr "org.hibernate.dialect.HSQLDialect"
+msgstr "<literal>org.hibernate.dialect.HSQLDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1540,9 +1065,9 @@
 msgstr "Ingres"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.IngresDialect</literal>"
-msgstr "org.hibernate.dialect.IngresDialect"
+msgstr "<literal>org.hibernate.dialect.IngresDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1550,9 +1075,9 @@
 msgstr "Progress"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.ProgressDialect</literal>"
-msgstr "org.hibernate.dialect.ProgressDialect"
+msgstr "<literal>org.hibernate.dialect.ProgressDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1560,9 +1085,9 @@
 msgstr "Mckoi SQL"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.MckoiDialect</literal>"
-msgstr "org.hibernate.dialect.MckoiDialect"
+msgstr "<literal>org.hibernate.dialect.MckoiDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1570,9 +1095,9 @@
 msgstr "Interbase"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.InterbaseDialect</literal>"
-msgstr "org.hibernate.dialect.InterbaseDialect"
+msgstr "<literal>org.hibernate.dialect.InterbaseDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1580,9 +1105,9 @@
 msgstr "Pointbase"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.PointbaseDialect</literal>"
-msgstr "org.hibernate.dialect.PointbaseDialect"
+msgstr "<literal>org.hibernate.dialect.PointbaseDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1590,9 +1115,9 @@
 msgstr "FrontBase"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.FrontbaseDialect</literal>"
-msgstr "org.hibernate.dialect.FrontbaseDialect"
+msgstr "<literal>org.hibernate.dialect.FrontbaseDialect</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1600,9 +1125,9 @@
 msgstr "Firebird"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.dialect.FirebirdDialect</literal>"
-msgstr "org.hibernate.dialect.FirebirdDialect"
+msgstr "<literal>org.hibernate.dialect.FirebirdDialect</literal>"
 
 #. Tag: title
 #, no-c-format
@@ -1611,39 +1136,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If your database supports ANSI, Oracle or Sybase style outer joins, "
-"<emphasis>outer join fetching</emphasis> will often increase performance by "
-"limiting the number of round trips to and from the database. This is, "
-"however, at the cost of possibly more work performed by the database itself. "
-"Outer join fetching allows a whole graph of objects connected by many-to-"
-"one, one-to-many, many-to-many and one-to-one associations to be retrieved "
-"in a single SQL <literal>SELECT</literal>."
-msgstr ""
-"å¦‚æžœä½ çš„æ•°æ®åº“æ”¯æŒ ANSI、Oracle 或 Sybase é£Žæ ¼çš„å¤–è¿žæŽ¥ï¼Œ<emphasis>外连接抓取"
-"</emphasis>通常能通过限制往返数据库次数（更多的工作交由数据库自己来完成）来提"
-"高效率。外连接抓取允许在单个 <literal>SELECT</literal> SQL 语句中， 通过 "
-"many-to-one、one-to-many、many-to-many 和 one-to-one 关联获取连接对象的整个对"
-"象图。"
+msgid "If your database supports ANSI, Oracle or Sybase style outer joins, <emphasis>outer join fetching</emphasis> will often increase performance by limiting the number of round trips to and from the database. This is, however, at the cost of possibly more work performed by the database itself. Outer join fetching allows a whole graph of objects connected by many-to-one, one-to-many, many-to-many and one-to-one associations to be retrieved in a single SQL <literal>SELECT</literal>."
+msgstr "å¦‚æžœä½ çš„æ•°æ®åº“æ”¯æŒ ANSI、Oracle 或 Sybase é£Žæ ¼çš„å¤–è¿žæŽ¥ï¼Œ<emphasis>外连接抓取</emphasis>通常能通过限制往返数据库次数（更多的工作交由数据库自己来完成）来提高效率。外连接抓取允许在单个 <literal>SELECT</literal> SQL 语句中， 通过 many-to-one、one-to-many、many-to-many å’Œ one-to-one 关联获取连接对象的整个对象图。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Outer join fetching can be disabled <emphasis>globally</emphasis> by setting "
-"the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</"
-"literal>. A setting of <literal>1</literal> or higher enables outer join "
-"fetching for one-to-one and many-to-one associations that have been mapped "
-"with <literal>fetch=\"join\"</literal>."
-msgstr ""
-"将 <literal>hibernate.max_fetch_depth</literal> 设为 <literal>0</literal> 能"
-"在<emphasis>全局</emphasis> 范围内禁止外连接抓取。设为 <literal>1</literal> "
-"或更高值能启用 one-to-one 和 many-to-oneouter 关联的外连接抓取，它们通过 "
-"<literal>fetch=\"join\"</literal> æ¥æ˜ å°„ã€‚ "
+msgid "Outer join fetching can be disabled <emphasis>globally</emphasis> by setting the property <literal>hibernate.max_fetch_depth</literal> to <literal>0</literal>. A setting of <literal>1</literal> or higher enables outer join fetching for one-to-one and many-to-one associations that have been mapped with <literal>fetch=\"join\"</literal>."
+msgstr "å°† <literal>hibernate.max_fetch_depth</literal> 设为 <literal>0</literal> 能在<emphasis>全局</emphasis> 范围内禁止外连接抓取。设为 <literal>1</literal> 或更高值能启用 one-to-one å’Œ many-to-oneouter 关联的外连接抓取，它们通过 <literal>fetch=\"join\"</literal> æ¥æ˜ å°„ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "See <xref linkend=\"performance-fetching\" /> for more information."
-msgstr "参见 <xref linkend=\"performance-fetching\"/> 获得更多信息。"
+msgstr "参见 <xref linkend=\"performance-fetching\"/> 获得更多信息。 "
 
 #. Tag: title
 #, no-c-format
@@ -1652,17 +1156,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Oracle limits the size of <literal>byte</literal> arrays that can be passed "
-"to and/or from its JDBC driver. If you wish to use large instances of "
-"<literal>binary</literal> or <literal>serializable</literal> type, you "
-"should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. "
-"<emphasis>This is a system-level setting only.</emphasis>"
-msgstr ""
-"Oracle 限制那些通过 JDBC é©±åŠ¨ä¼ è¾“çš„<literal>字节</literal>æ•°ç»„çš„æ•°ç›®ã€‚å¦‚æžœä½ "
-"希望使用<literal>二进值（binary）</literal>或 <literal>可序列化的"
-"（serializable）</literal>ç±»åž‹çš„å¤§å¯¹è±¡ï¼Œä½ åº”è¯¥å¼€å¯ <literal>hibernate.jdbc."
-"use_streams_for_binary</literal> 属性。<emphasis>这是系统级属性。</emphasis> "
+msgid "Oracle limits the size of <literal>byte</literal> arrays that can be passed to and/or from its JDBC driver. If you wish to use large instances of <literal>binary</literal> or <literal>serializable</literal> type, you should enable <literal>hibernate.jdbc.use_streams_for_binary</literal>. <emphasis>This is a system-level setting only.</emphasis>"
+msgstr "Oracle 限制那些通过 JDBC é©±åŠ¨ä¼ è¾“çš„<literal>字节</literal>æ•°ç»„çš„æ•°ç›®ã€‚å¦‚æžœä½ å¸Œæœ›ä½¿ç”¨<literal>二进值（binary）</literal>或 <literal>可序列化的（serializable）</literal>ç±»åž‹çš„å¤§å¯¹è±¡ï¼Œä½ åº”è¯¥å¼€å¯ <literal>hibernate.jdbc.use_streams_for_binary</literal> 属性。<emphasis>这是系统级属性。</emphasis> "
 
 #. Tag: title
 #, no-c-format
@@ -1670,15 +1165,9 @@
 msgstr "二级缓存与查询缓存"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The properties prefixed by <literal>hibernate.cache</literal> allow you to "
-"use a process or cluster scoped second-level cache system with Hibernate. "
-"See the <xref linkend=\"performance-cache\" /> for more information."
-msgstr ""
-"以 <literal>hibernate.cache</literal> ä¸ºå‰ç¼€çš„å±žæ€§å…è®¸ä½ åœ¨ Hibernate 中，使用"
-"进程或群集范围内的二级缓存系统。参见 <xref linkend=\"performance-cache\"/> 获"
-"取更多的详情."
+#, no-c-format
+msgid "The properties prefixed by <literal>hibernate.cache</literal> allow you to use a process or cluster scoped second-level cache system with Hibernate. See the <xref linkend=\"performance-cache\" /> for more information."
+msgstr "以 <literal>hibernate.cache</literal> ä¸ºå‰ç¼€çš„å±žæ€§å…è®¸ä½ åœ¨ Hibernate 中，使用进程或群集范围内的二级缓存系统。参见 <xref linkend=\"performance-cache\"/> 获取更多的详情. "
 
 #. Tag: title
 #, no-c-format
@@ -1687,26 +1176,17 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can define new Hibernate query tokens using <literal>hibernate.query."
-"substitutions</literal>. For example:"
-msgstr ""
-"ä½ å¯ä»¥ä½¿ç”¨ <literal>hibernate.query.substitutions</literal> 在 Hibernate 中定"
-"义新的查询符号。例如： "
+msgid "You can define new Hibernate query tokens using <literal>hibernate.query.substitutions</literal>. For example:"
+msgstr "ä½ å¯ä»¥ä½¿ç”¨ <literal>hibernate.query.substitutions</literal> 在 Hibernate 中定义新的查询符号。例如： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This would cause the tokens <literal>true</literal> and <literal>false</"
-"literal> to be translated to integer literals in the generated SQL."
-msgstr ""
-"将导致符号 <literal>true</literal> 和 <literal>false</literal> 在生成的 SQL "
-"中被翻译成整数常量。"
+msgid "This would cause the tokens <literal>true</literal> and <literal>false</literal> to be translated to integer literals in the generated SQL."
+msgstr "将导致符号 <literal>true</literal> 和 <literal>false</literal> 在生成的 SQL 中被翻译成整数常量。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This would allow you to rename the SQL <literal>LOWER</literal> function."
+msgid "This would allow you to rename the SQL <literal>LOWER</literal> function."
 msgstr "å°†å…è®¸ä½ é‡å‘½å SQL 中的 <literal>LOWER</literal> 函数。"
 
 #. Tag: title
@@ -1716,18 +1196,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you enable <literal>hibernate.generate_statistics</literal>, Hibernate "
-"exposes a number of metrics that are useful when tuning a running system via "
-"<literal>SessionFactory.getStatistics()</literal>. Hibernate can even be "
-"configured to expose these statistics via JMX. Read the Javadoc of the "
-"interfaces in <literal>org.hibernate.stats</literal> for more information."
-msgstr ""
-"å¦‚æžœä½ å¼€å¯ <literal>hibernate.generate_statistics</literal>ï¼Œé‚£ä¹ˆå½“ä½ é€šè¿‡  "
-"<literal>SessionFactory.getStatistics()</literal> 调整正在运行的系统时，"
-"Hibernate 将导出大量有用的数据。Hibernate 甚至能被配置成通过 JMX 导出这些统计"
-"信息。参考 <literal>org.hibernate.stats</literal> 中接口的 Javadoc，以获得更"
-"多信息。 "
+msgid "If you enable <literal>hibernate.generate_statistics</literal>, Hibernate exposes a number of metrics that are useful when tuning a running system via <literal>SessionFactory.getStatistics()</literal>. Hibernate can even be configured to expose these statistics via JMX. Read the Javadoc of the interfaces in <literal>org.hibernate.stats</literal> for more information."
+msgstr "å¦‚æžœä½ å¼€å¯ <literal>hibernate.generate_statistics</literal>ï¼Œé‚£ä¹ˆå½“ä½ é€šè¿‡  <literal>SessionFactory.getStatistics()</literal> 调整正在运行的系统时，Hibernate 将导出大量有用的数据。Hibernate 甚至能被配置成通过 JMX 导出这些统计信息。参考 <literal>org.hibernate.stats</literal> 中接口的 Javadoc，以获得更多信息。 "
 
 #. Tag: title
 #, no-c-format
@@ -1736,42 +1206,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate utilizes <ulink url=\"http://www.slf4j.org/\">Simple Logging "
-"Facade for Java</ulink> (SLF4J) in order to log various system events. SLF4J "
-"can direct your logging output to several logging frameworks (NOP, Simple, "
-"log4j version 1.2, JDK 1.4 logging, JCL or logback) depending on your chosen "
-"binding. In order to setup logging you will need <filename>slf4j-api.jar</"
-"filename> in your classpath together with the jar file for your preferred "
-"binding - <filename>slf4j-log4j12.jar</filename> in the case of Log4J. See "
-"the SLF4J <ulink url=\"http://www.slf4j.org/manual.html\">documentation</"
-"ulink> for more detail. To use Log4j you will also need to place a "
-"<filename>log4j.properties</filename> file in your classpath. An example "
-"properties file is distributed with Hibernate in the <literal>src/</literal> "
-"directory."
-msgstr ""
-"Hibernate 利用 <ulink url=\"http://www.slf4j.org/\">Simple Logging Facade "
-"for Java</ulink> (SLF4J) 来记录不同系统事件的日志。SLF4J å¯ä»¥æ ¹æ®ä½ é€‰æ‹©çš„ç»‘å®š"
-"æŠŠæ—¥å¿—è¾“å‡ºåˆ°å‡ ä¸ªæ—¥å¿—æ¡†æž¶ï¼ˆNOP、Simple、log4j version 1.2、JDK 1.4 logging、"
-"JCL 或 logbackï¼‰ä¸Šã€‚ä¸ºäº†è®¾ç½®æ—¥å¿—ï¼Œä½ éœ€è¦åœ¨ classpath é‡ŒåŠ å…¥ <filename>slf4j-"
-"api.jar</filename> å’Œä½ é€‰æ‹©çš„ç»‘å®šçš„ JAR 文件（使用 Log4J æ—¶åŠ å…¥ "
-"<filename>slf4j-log4j12.jar</filename>）。更多的细节请参考 SLF4J <ulink url="
-"\"http://www.slf4j.org/manual.html\">文档</ulink>。要使用 Log4jï¼Œä½ ä¹Ÿéœ€è¦åœ¨ "
-"classpath é‡ŒåŠ å…¥ <filename>log4j.properties</filename> 文件。Hibernate 里的 "
-"<literal>src/</literal> 目录里带有一个属性文件的例子。"
+msgid "Hibernate utilizes <ulink url=\"http://www.slf4j.org/\">Simple Logging Facade for Java</ulink> (SLF4J) in order to log various system events. SLF4J can direct your logging output to several logging frameworks (NOP, Simple, log4j version 1.2, JDK 1.4 logging, JCL or logback) depending on your chosen binding. In order to setup logging you will need <filename>slf4j-api.jar</filename> in your classpath together with the jar file for your preferred binding - <filename>slf4j-log4j12.jar</filename> in the case of Log4J. See the SLF4J <ulink url=\"http://www.slf4j.org/manual.html\">documentation</ulink> for more detail. To use Log4j you will also need to place a <filename>log4j.properties</filename> file in your classpath. An example properties file is distributed with Hibernate in the <literal>src/</literal> directory."
+msgstr "Hibernate 利用 <ulink url=\"http://www.slf4j.org/\">Simple Logging Facade for Java</ulink> (SLF4J) 来记录不同系统事件的日志。SLF4J å¯ä»¥æ ¹æ®ä½ é€‰æ‹©çš„ç»‘å®šæŠŠæ—¥å¿—è¾“å‡ºåˆ°å‡ ä¸ªæ—¥å¿—æ¡†æž¶ï¼ˆNOP、Simple、log4j version 1.2、JDK 1.4 logging、JCL 或 logbackï¼‰ä¸Šã€‚ä¸ºäº†è®¾ç½®æ—¥å¿—ï¼Œä½ éœ€è¦åœ¨ classpath é‡ŒåŠ å…¥ <filename>slf4j-api.jar</filename> å’Œä½ é€‰æ‹©çš„ç»‘å®šçš„ JAR 文件（使用 Log4J æ—¶åŠ å…¥ <filename>slf4j-log4j12.jar</filename>）。更多的细节请参考 SLF4J <ulink url=\"http://www.slf4j.org/manual.html\">文档</ulink>。要使用 Log4jï¼Œä½ ä¹Ÿéœ€è¦åœ¨ classpath é‡ŒåŠ å…¥ <filename>log4j.properties</filename> 文件。Hibernate 里的 <literal>src/</literal> 目录里带有一个属性文件的例子。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is recommended that you familiarize yourself with Hibernate's log "
-"messages. A lot of work has been put into making the Hibernate log as "
-"detailed as possible, without making it unreadable. It is an essential "
-"troubleshooting device. The most interesting log categories are the "
-"following:"
-msgstr ""
-"æˆ‘ä»¬å¼ºçƒˆå»ºè®®ä½ ç†Ÿæ‚‰ä¸€ä¸‹ Hibernate 的日志消息。在不失可读性的前提下，我们做了很"
-"多工作，使 Hibernate 的日志可能地详细。这是必要的查错利器。最令人感兴趣的日志"
-"分类有如下这些："
+msgid "It is recommended that you familiarize yourself with Hibernate's log messages. A lot of work has been put into making the Hibernate log as detailed as possible, without making it unreadable. It is an essential troubleshooting device. The most interesting log categories are the following:"
+msgstr "æˆ‘ä»¬å¼ºçƒˆå»ºè®®ä½ ç†Ÿæ‚‰ä¸€ä¸‹ Hibernate 的日志消息。在不失可读性的前提下，我们做了很多工作，使 Hibernate 的日志可能地详细。这是必要的查错利器。最令人感兴趣的日志分类有如下这些："
 
 #. Tag: title
 #, no-c-format
@@ -1789,9 +1230,9 @@
 msgstr "功能"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.SQL</literal>"
-msgstr "org.hibernate.SQL"
+msgstr "<literal>org.hibernate.SQL</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1799,9 +1240,9 @@
 msgstr "在所有 SQL DML 语句被执行时为它们记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.type</literal>"
-msgstr "org.hibernate.type"
+msgstr "<literal>org.hibernate.type</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1809,9 +1250,9 @@
 msgstr "为所有 JDBC 参数记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.tool. hbm2ddl</literal>"
-msgstr "org.hibernate.tool.hbm2ddl"
+msgstr "<literal>org.hibernate.tool. hbm2ddl</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1819,22 +1260,19 @@
 msgstr "在所有 SQL DDL 语句执行时为它们记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.pretty</literal>"
-msgstr "org.hibernate.pretty"
+msgstr "<literal>org.hibernate.pretty</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Log the state of all entities (max 20 entities) associated with the session "
-"at flush time"
-msgstr ""
-"在 session 清洗（flush）时，为所有与其关联的实体（最多 20 个）的状态记录日志"
+msgid "Log the state of all entities (max 20 entities) associated with the session at flush time"
+msgstr "在 session 清洗（flush）时，为所有与其关联的实体（最多 20 个）的状态记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.cache</literal>"
-msgstr "org.hibernate.cache"
+msgstr "<literal>org.hibernate.cache</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1842,9 +1280,9 @@
 msgstr "为所有二级缓存的活动记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate. transaction</literal>"
-msgstr "org.hibernate.transaction"
+msgstr "<literal>org.hibernate. transaction</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1852,9 +1290,9 @@
 msgstr "为事务相关的活动记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.jdbc</literal>"
-msgstr "org.hibernate.jdbc"
+msgstr "<literal>org.hibernate.jdbc</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1862,9 +1300,9 @@
 msgstr "为所有 JDBC 资源的获取记录日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.hql. ast.AST</literal>"
-msgstr "org.hibernate.hql.AST"
+msgstr "<literal>org.hibernate.hql. ast.AST</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1872,9 +1310,9 @@
 msgstr "在解析查询的时候,记录 HQL 和 SQL 的 AST 分析日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.secure</literal>"
-msgstr "org.hibernate.secure"
+msgstr "<literal>org.hibernate.secure</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -1882,28 +1320,19 @@
 msgstr "为 JAAS 认证请求做日志"
 
 #. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate</literal>"
-msgstr "JNDI 绑定的 <literal>SessionFactory</literal>"
+msgstr "<literal>org.hibernate</literal>"
 
 #. Tag: entry
 #, no-c-format
-msgid ""
-"Log everything. This is a lot of information but it is useful for "
-"troubleshooting"
+msgid "Log everything. This is a lot of information but it is useful for troubleshooting"
 msgstr "为任何 Hibernate 相关信息记录日志（信息量较大，但对查错非常有帮助）"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"When developing applications with Hibernate, you should almost always work "
-"with <literal>debug</literal> enabled for the category <literal>org."
-"hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate."
-"show_sql</literal> enabled."
-msgstr ""
-"在使用 Hibernate å¼€å‘åº”ç”¨ç¨‹åºæ—¶ï¼Œä½ åº”å½“æ€»æ˜¯ä¸º <literal>org.hibernate.SQL</"
-"literal> 开启 <literal>debug</literal> 级别的日志记录,或者开启 "
-"<literal>hibernate.show_sql</literal> 属性。"
+msgid "When developing applications with Hibernate, you should almost always work with <literal>debug</literal> enabled for the category <literal>org.hibernate.SQL</literal>, or, alternatively, the property <literal>hibernate.show_sql</literal> enabled."
+msgstr "在使用 Hibernate å¼€å‘åº”ç”¨ç¨‹åºæ—¶ï¼Œä½ åº”å½“æ€»æ˜¯ä¸º <literal>org.hibernate.SQL</literal> 开启 <literal>debug</literal> 级别的日志记录,或者开启 <literal>hibernate.show_sql</literal> 属性。"
 
 #. Tag: title
 #, no-c-format
@@ -1912,44 +1341,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you "
-"to specify a \"naming standard\" for database objects and schema elements."
-msgstr ""
-"<literal>org.hibernate.cfg.NamingStrategy</literal> æŽ¥å£å…è®¸ä½ ä¸ºæ•°æ®åº“ä¸­çš„å¯¹"
-"象和 schema å…ƒç´ æŒ‡å®šä¸€ä¸ªâ€œå‘½åæ ‡å‡†â€ã€‚"
+msgid "The interface <literal>org.hibernate.cfg.NamingStrategy</literal> allows you to specify a \"naming standard\" for database objects and schema elements."
+msgstr "<literal>org.hibernate.cfg.NamingStrategy</literal> æŽ¥å£å…è®¸ä½ ä¸ºæ•°æ®åº“ä¸­çš„å¯¹è±¡å’Œ schema å…ƒç´ æŒ‡å®šä¸€ä¸ªâ€œå‘½åæ ‡å‡†â€ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can provide rules for automatically generating database identifiers from "
-"Java identifiers or for processing \"logical\" column and table names given "
-"in the mapping file into \"physical\" table and column names. This feature "
-"helps reduce the verbosity of the mapping document, eliminating repetitive "
-"noise (<literal>TBL_</literal> prefixes, for example). The default strategy "
-"used by Hibernate is quite minimal."
-msgstr ""
-"ä½ å¯èƒ½ä¼šæä¾›ä¸€äº›é€šè¿‡ Java æ ‡è¯†ç”Ÿæˆæ•°æ®åº“æ ‡è¯†æˆ–å°†æ˜ å°„å®šä¹‰æ–‡ä»¶ä¸­\"逻辑\"表/列名"
-"处理成\"物理\"表/åˆ—åçš„è§„åˆ™ã€‚è¿™ä¸ªç‰¹æ€§æœ‰åŠ©äºŽå‡å°‘å†—é•¿çš„æ˜ å°„å®šä¹‰æ–‡ä»¶ï¼Œæ¶ˆé™¤é‡å¤å†…"
-"容（如 <literal>TBL_</literal> 前缀）。Hibernate 使用的缺省策略是相当精简的。"
+msgid "You can provide rules for automatically generating database identifiers from Java identifiers or for processing \"logical\" column and table names given in the mapping file into \"physical\" table and column names. This feature helps reduce the verbosity of the mapping document, eliminating repetitive noise (<literal>TBL_</literal> prefixes, for example). The default strategy used by Hibernate is quite minimal."
+msgstr "ä½ å¯èƒ½ä¼šæä¾›ä¸€äº›é€šè¿‡ Java æ ‡è¯†ç”Ÿæˆæ•°æ®åº“æ ‡è¯†æˆ–å°†æ˜ å°„å®šä¹‰æ–‡ä»¶ä¸­\"逻辑\"表/列名处理成\"物理\"表/åˆ—åçš„è§„åˆ™ã€‚è¿™ä¸ªç‰¹æ€§æœ‰åŠ©äºŽå‡å°‘å†—é•¿çš„æ˜ å°„å®šä¹‰æ–‡ä»¶ï¼Œæ¶ˆé™¤é‡å¤å†…å®¹ï¼ˆå¦‚ <literal>TBL_</literal> 前缀）。Hibernate 使用的缺省策略是相当精简的。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can specify a different strategy by calling <literal>Configuration."
-"setNamingStrategy()</literal> before adding mappings:"
-msgstr ""
-"åœ¨åŠ å…¥æ˜ å°„å®šä¹‰å‰ï¼Œä½ å¯ä»¥è°ƒç”¨ <literal>Configuration.setNamingStrategy()</"
-"literal> 指定一个不同的命名策略： "
+msgid "You can specify a different strategy by calling <literal>Configuration.setNamingStrategy()</literal> before adding mappings:"
+msgstr "åœ¨åŠ å…¥æ˜ å°„å®šä¹‰å‰ï¼Œä½ å¯ä»¥è°ƒç”¨ <literal>Configuration.setNamingStrategy()</literal> 指定一个不同的命名策略： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in "
-"strategy that might be a useful starting point for some applications."
-msgstr ""
-"<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> 是一个内建的命名"
-"策略，对一些应用程序而言，可能是非常有用的起点。"
+msgid "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> is a built-in strategy that might be a useful starting point for some applications."
+msgstr "<literal>org.hibernate.cfg.ImprovedNamingStrategy</literal> 是一个内建的命名策略，对一些应用程序而言，可能是非常有用的起点。"
 
 #. Tag: title
 #, no-c-format
@@ -1958,40 +1366,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An alternative approach to configuration is to specify a full configuration "
-"in a file named <literal>hibernate.cfg.xml</literal>. This file can be used "
-"as a replacement for the <literal>hibernate.properties</literal> file or, if "
-"both are present, to override properties."
-msgstr ""
-"另一个配置方法是在 <literal>hibernate.cfg.xml</literal> 文件中指定一套完整的"
-"配置。这个文件可以当成 <literal>hibernate.properties</literal> 的替代。若两个"
-"文件同时存在，它将覆盖前者的属性。"
+msgid "An alternative approach to configuration is to specify a full configuration in a file named <literal>hibernate.cfg.xml</literal>. This file can be used as a replacement for the <literal>hibernate.properties</literal> file or, if both are present, to override properties."
+msgstr "另一个配置方法是在 <literal>hibernate.cfg.xml</literal> 文件中指定一套完整的配置。这个文件可以当成 <literal>hibernate.properties</literal> 的替代。若两个文件同时存在，它将覆盖前者的属性。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The XML configuration file is by default expected to be in the root of your "
-"<literal>CLASSPATH</literal>. Here is an example:"
-msgstr ""
-"XML 配置文件被默认是放在 <literal>CLASSPATH</literal> çš„æ ¹ç›®å½•ä¸‹ã€‚ä¸‹é¢æ˜¯ä¸€ä¸ª"
-"例子： "
+msgid "The XML configuration file is by default expected to be in the root of your <literal>CLASSPATH</literal>. Here is an example:"
+msgstr "XML 配置文件被默认是放在 <literal>CLASSPATH</literal> çš„æ ¹ç›®å½•ä¸‹ã€‚ä¸‹é¢æ˜¯ä¸€ä¸ªä¾‹å­ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The advantage of this approach is the externalization of the mapping file "
-"names to configuration. The <literal>hibernate.cfg.xml</literal> is also "
-"more convenient once you have to tune the Hibernate cache. It is your choice "
-"to use either <literal>hibernate.properties</literal> or <literal>hibernate."
-"cfg.xml</literal>. Both are equivalent, except for the above mentioned "
-"benefits of using the XML syntax."
-msgstr ""
-"å¦‚ä½ æ‰€è§ï¼Œè¿™ä¸ªæ–¹æ³•ä¼˜åŠ¿åœ¨äºŽï¼Œåœ¨é…ç½®æ–‡ä»¶ä¸­æŒ‡å‡ºäº†æ˜ å°„å®šä¹‰æ–‡ä»¶çš„åå­—ã€‚ä¸€æ—¦ä½ éœ€è¦"
-"调整 Hibernate 的缓存，<literal>hibernate.cfg.xml</literal> 也是更方便。注"
-"意，使用 <literal>hibernate.properties</literal> 还是 <literal>hibernate.cfg."
-"xml</literal> å®Œå…¨æ˜¯ç”±ä½ æ¥å†³å®šï¼Œé™¤äº†ä¸Šé¢æåˆ°çš„ XML 语法的优势之外，两者是等价"
-"的。 "
+msgid "The advantage of this approach is the externalization of the mapping file names to configuration. The <literal>hibernate.cfg.xml</literal> is also more convenient once you have to tune the Hibernate cache. It is your choice to use either <literal>hibernate.properties</literal> or <literal>hibernate.cfg.xml</literal>. Both are equivalent, except for the above mentioned benefits of using the XML syntax."
+msgstr "å¦‚ä½ æ‰€è§ï¼Œè¿™ä¸ªæ–¹æ³•ä¼˜åŠ¿åœ¨äºŽï¼Œåœ¨é…ç½®æ–‡ä»¶ä¸­æŒ‡å‡ºäº†æ˜ å°„å®šä¹‰æ–‡ä»¶çš„åå­—ã€‚ä¸€æ—¦ä½ éœ€è¦è°ƒæ•´ Hibernate 的缓存，<literal>hibernate.cfg.xml</literal> 也是更方便。注意，使用 <literal>hibernate.properties</literal> 还是 <literal>hibernate.cfg.xml</literal> å®Œå…¨æ˜¯ç”±ä½ æ¥å†³å®šï¼Œé™¤äº†ä¸Šé¢æåˆ°çš„ XML 语法的优势之外，两者是等价的。 "
 
 #. Tag: para
 #, no-c-format
@@ -2015,78 +1401,28 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC "
-"connections managed by the container and provided through JNDI. Usually, a "
-"JTA compatible <literal>TransactionManager</literal> and a "
-"<literal>ResourceManager</literal> take care of transaction management "
-"(CMT), especially distributed transaction handling across several "
-"datasources. You can also demarcate transaction boundaries programmatically "
-"(BMT), or you might want to use the optional Hibernate <literal>Transaction</"
-"literal> API for this to keep your code portable."
-msgstr ""
-"<emphasis>容器管理的数据源（Container-managed datasources）</emphasis>： "
-"Hibernate 能使用通过容器管理，并由 JNDI 提供的 JDBC 连接。通常，特别是当处理"
-"多个数据源的分布式事务的时候，由一个 JTA 兼容的 <literal>TransactionManager</"
-"literal> 和一个 <literal>ResourceManager</literal> 来处理事务管理（CMT，容器"
-"ç®¡ç†çš„äº‹åŠ¡ï¼‰ã€‚å½“ç„¶ä½ å¯ä»¥é€šè¿‡ 编程方式来划分事务边界（BMT，Bean 管理的事务）。"
-"æˆ–è€…ä¸ºäº†ä»£ç çš„å¯ç§»æ¤æ€§ï¼Œä½ ä¹Ÿä¹Ÿè®¸ä¼šæƒ³ä½¿ç”¨å¯é€‰çš„ Hibernate "
-"<literal>Transaction</literal> API。 "
+msgid "<emphasis>Container-managed datasources</emphasis>: Hibernate can use JDBC connections managed by the container and provided through JNDI. Usually, a JTA compatible <literal>TransactionManager</literal> and a <literal>ResourceManager</literal> take care of transaction management (CMT), especially distributed transaction handling across several datasources. You can also demarcate transaction boundaries programmatically (BMT), or you might want to use the optional Hibernate <literal>Transaction</literal> API for this to keep your code portable."
+msgstr "<emphasis>容器管理的数据源（Container-managed datasources）</emphasis>： Hibernate 能使用通过容器管理，并由 JNDI 提供的 JDBC 连接。通常，特别是当处理多个数据源的分布式事务的时候，由一个 JTA 兼容的 <literal>TransactionManager</literal> 和一个 <literal>ResourceManager</literal> 来处理事务管理（CMTï¼Œå®¹å™¨ç®¡ç†çš„äº‹åŠ¡ï¼‰ã€‚å½“ç„¶ä½ å¯ä»¥é€šè¿‡ 编程方式来划分事务边界（BMT，Bean ç®¡ç†çš„äº‹åŠ¡ï¼‰ã€‚æˆ–è€…ä¸ºäº†ä»£ç çš„å¯ç§»æ¤æ€§ï¼Œä½ ä¹Ÿä¹Ÿè®¸ä¼šæƒ³ä½¿ç”¨å¯é€‰çš„ Hibernate <literal>Transaction</literal> API。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its "
-"<literal>SessionFactory</literal> to JNDI after startup."
-msgstr ""
-"<emphasis>自动 JNDI 绑定</emphasis>：Hibernate 可以在启动后将 "
-"<literal>SessionFactory</literal> 绑定到 JNDI。"
+msgid "<emphasis>Automatic JNDI binding</emphasis>: Hibernate can bind its <literal>SessionFactory</literal> to JNDI after startup."
+msgstr "<emphasis>自动 JNDI 绑定</emphasis>：Hibernate 可以在启动后将 <literal>SessionFactory</literal> 绑定到 JNDI。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>JTA Session binding:</emphasis> the Hibernate <literal>Session</"
-"literal> can be automatically bound to the scope of JTA transactions. Simply "
-"lookup the <literal>SessionFactory</literal> from JNDI and get the current "
-"<literal>Session</literal>. Let Hibernate manage flushing and closing the "
-"<literal>Session</literal> when your JTA transaction completes. Transaction "
-"demarcation is either declarative (CMT) or programmatic (BMT/"
-"UserTransaction)."
-msgstr ""
-"<emphasis>JTA Session 绑定：</emphasis> Hibernate <literal>Session</literal> "
-"可以自动绑定到 JTA 事务作用的范围。只需简单地从 JNDI 查找 "
-"<literal>SessionFactory</literal> 并获得当前的 <literal>Session</literal>。"
-"当 JTA 事务完成时，让 Hibernate来处理 <literal>Session</literal> 的清洗"
-"（flush）与关闭。事务的划分可以是声明式的（CMT）,也可以是编程式的（BMT/"
-"UserTransaction）。 "
+msgid "<emphasis>JTA Session binding:</emphasis> the Hibernate <literal>Session</literal> can be automatically bound to the scope of JTA transactions. Simply lookup the <literal>SessionFactory</literal> from JNDI and get the current <literal>Session</literal>. Let Hibernate manage flushing and closing the <literal>Session</literal> when your JTA transaction completes. Transaction demarcation is either declarative (CMT) or programmatic (BMT/UserTransaction)."
+msgstr "<emphasis>JTA Session 绑定：</emphasis> Hibernate <literal>Session</literal> 可以自动绑定到 JTA 事务作用的范围。只需简单地从 JNDI 查找 <literal>SessionFactory</literal> 并获得当前的 <literal>Session</literal>。当 JTA 事务完成时，让 Hibernate来处理 <literal>Session</literal> 的清洗（flush）与关闭。事务的划分可以是声明式的（CMT）,也可以是编程式的（BMT/UserTransaction）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>JMX deployment:</emphasis> if you have a JMX capable application "
-"server (e.g. JBoss AS), you can choose to deploy Hibernate as a managed "
-"MBean. This saves you the one line startup code to build your "
-"<literal>SessionFactory</literal> from a <literal>Configuration</literal>. "
-"The container will startup your <literal>HibernateService</literal> and also "
-"take care of service dependencies (datasource has to be available before "
-"Hibernate starts, etc)."
-msgstr ""
-"<emphasis>JMX 部署：</emphasis> å¦‚æžœä½ ä½¿ç”¨æ”¯æŒ JMX 应用程序服务器（如，JBoss "
-"ASï¼‰ï¼Œé‚£ä¹ˆä½ å¯ä»¥é€‰æ‹©å°† Hibernate 部署成托管 MBeanã€‚è¿™å°†ä¸ºä½ çœåŽ»ä¸€è¡Œä»Ž"
-"<literal>Configuration</literal> 构建 <literal>SessionFactory</literal> 的启"
-"åŠ¨ä»£ç ã€‚å®¹å™¨å°†å¯åŠ¨ä½ çš„ <literal>HibernateService</literal>，并完美地处理好服"
-"务间的依赖关系（在 Hibernate 启动前，数据源必须是可用的，等等）。 "
+msgid "<emphasis>JMX deployment:</emphasis> if you have a JMX capable application server (e.g. JBoss AS), you can choose to deploy Hibernate as a managed MBean. This saves you the one line startup code to build your <literal>SessionFactory</literal> from a <literal>Configuration</literal>. The container will startup your <literal>HibernateService</literal> and also take care of service dependencies (datasource has to be available before Hibernate starts, etc)."
+msgstr "<emphasis>JMX 部署：</emphasis> å¦‚æžœä½ ä½¿ç”¨æ”¯æŒ JMX 应用程序服务器（如，JBoss ASï¼‰ï¼Œé‚£ä¹ˆä½ å¯ä»¥é€‰æ‹©å°† Hibernate 部署成托管 MBeanã€‚è¿™å°†ä¸ºä½ çœåŽ»ä¸€è¡Œä»Ž<literal>Configuration</literal> 构建 <literal>SessionFactory</literal> çš„å¯åŠ¨ä»£ç ã€‚å®¹å™¨å°†å¯åŠ¨ä½ çš„ <literal>HibernateService</literal>，并完美地处理好服务间的依赖关系（在 Hibernate 启动前，数据源必须是可用的，等等）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Depending on your environment, you might have to set the configuration "
-"option <literal>hibernate.connection.aggressive_release</literal> to true if "
-"your application server shows \"connection containment\" exceptions."
-msgstr ""
-"如果应用程序服务器抛出 \"connection containment\" å¼‚å¸¸ï¼Œæ ¹æ®ä½ çš„çŽ¯å¢ƒï¼Œä¹Ÿè®¸è¯¥"
-"将配置属性 <literal>hibernate.connection.release_mode</literal> 设为 "
-"<literal>after_statement</literal>。"
+msgid "Depending on your environment, you might have to set the configuration option <literal>hibernate.connection.aggressive_release</literal> to true if your application server shows \"connection containment\" exceptions."
+msgstr "如果应用程序服务器抛出 \"connection containment\" å¼‚å¸¸ï¼Œæ ¹æ®ä½ çš„çŽ¯å¢ƒï¼Œä¹Ÿè®¸è¯¥å°†é…ç½®å±žæ€§ <literal>hibernate.connection.release_mode</literal> 设为 <literal>after_statement</literal>。"
 
 #. Tag: title
 #, no-c-format
@@ -2095,33 +1431,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The Hibernate <literal>Session</literal> API is independent of any "
-"transaction demarcation system in your architecture. If you let Hibernate "
-"use JDBC directly through a connection pool, you can begin and end your "
-"transactions by calling the JDBC API. If you run in a J2EE application "
-"server, you might want to use bean-managed transactions and call the JTA API "
-"and <literal>UserTransaction</literal> when needed."
-msgstr ""
-"åœ¨ä½ çš„æž¶æž„ä¸­ï¼ŒHibernate çš„ <literal>Session</literal> API 是独立于任何事务分"
-"ç•Œç³»ç»Ÿçš„ã€‚å¦‚æžœä½ è®© Hibernate é€šè¿‡è¿žæŽ¥æ± ç›´æŽ¥ä½¿ç”¨ JDBCï¼Œä½ éœ€è¦è°ƒç”¨ JDBC API 来"
-"æ‰“å¼€å’Œå…³é—­ä½ çš„äº‹åŠ¡ã€‚å¦‚æžœä½ è¿è¡Œåœ¨ J2EE åº”ç”¨ç¨‹åºæœåŠ¡å™¨ä¸­ï¼Œä½ ä¹Ÿè®¸æƒ³ç”¨ Bean 管理"
-"的事务并在需要的时候调用 JTA API 和 <literal>UserTransaction</literal>。 "
+msgid "The Hibernate <literal>Session</literal> API is independent of any transaction demarcation system in your architecture. If you let Hibernate use JDBC directly through a connection pool, you can begin and end your transactions by calling the JDBC API. If you run in a J2EE application server, you might want to use bean-managed transactions and call the JTA API and <literal>UserTransaction</literal> when needed."
+msgstr "åœ¨ä½ çš„æž¶æž„ä¸­ï¼ŒHibernate çš„ <literal>Session</literal> API æ˜¯ç‹¬ç«‹äºŽä»»ä½•äº‹åŠ¡åˆ†ç•Œç³»ç»Ÿçš„ã€‚å¦‚æžœä½ è®© Hibernate é€šè¿‡è¿žæŽ¥æ± ç›´æŽ¥ä½¿ç”¨ JDBCï¼Œä½ éœ€è¦è°ƒç”¨ JDBC API æ¥æ‰“å¼€å’Œå…³é—­ä½ çš„äº‹åŠ¡ã€‚å¦‚æžœä½ è¿è¡Œåœ¨ J2EE åº”ç”¨ç¨‹åºæœåŠ¡å™¨ä¸­ï¼Œä½ ä¹Ÿè®¸æƒ³ç”¨ Bean 管理的事务并在需要的时候调用 JTA API å’Œ <literal>UserTransaction</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"To keep your code portable between these two (and other) environments we "
-"recommend the optional Hibernate <literal>Transaction</literal> API, which "
-"wraps and hides the underlying system. You have to specify a factory class "
-"for <literal>Transaction</literal> instances by setting the Hibernate "
-"configuration property <literal>hibernate.transaction.factory_class</"
-"literal>."
-msgstr ""
-"ä¸ºäº†è®©ä½ çš„ä»£ç åœ¨ä¸¤ç§ï¼ˆæˆ–å…¶ä»–ï¼‰çŽ¯å¢ƒä¸­å¯ä»¥ç§»æ¤ï¼Œæˆ‘ä»¬å»ºè®®ä½¿ç”¨å¯é€‰çš„ Hibernate "
-"<literal>Transaction</literal> APIï¼Œå®ƒåŒ…è£…å¹¶éšè—äº†åº•å±‚ç³»ç»Ÿã€‚ä½ å¿…é¡»é€šè¿‡è®¾ç½® "
-"Hibernate 配置属性 <literal>hibernate.transaction.factory_class</literal> 来"
-"指定一个 <literal>Transaction</literal> 实例的工厂类。"
+msgid "To keep your code portable between these two (and other) environments we recommend the optional Hibernate <literal>Transaction</literal> API, which wraps and hides the underlying system. You have to specify a factory class for <literal>Transaction</literal> instances by setting the Hibernate configuration property <literal>hibernate.transaction.factory_class</literal>."
+msgstr "ä¸ºäº†è®©ä½ çš„ä»£ç åœ¨ä¸¤ç§ï¼ˆæˆ–å…¶ä»–ï¼‰çŽ¯å¢ƒä¸­å¯ä»¥ç§»æ¤ï¼Œæˆ‘ä»¬å»ºè®®ä½¿ç”¨å¯é€‰çš„ Hibernate <literal>Transaction</literal> APIï¼Œå®ƒåŒ…è£…å¹¶éšè—äº†åº•å±‚ç³»ç»Ÿã€‚ä½ å¿…é¡»é€šè¿‡è®¾ç½® Hibernate 配置属性 <literal>hibernate.transaction.factory_class</literal> 来指定一个 <literal>Transaction</literal> 实例的工厂类。"
 
 #. Tag: para
 #, no-c-format
@@ -2129,9 +1445,9 @@
 msgstr "æœ‰ä¸‰ä¸ªæ ‡å‡†ï¼ˆå†…å»ºï¼‰çš„é€‰æ‹©ï¼š "
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.transaction.JDBCTransactionFactory</literal>"
-msgstr "org.hibernate.transaction.JDBCTransactionFactory"
+msgstr "<literal>org.hibernate.transaction.JDBCTransactionFactory</literal>"
 
 #. Tag: para
 #, no-c-format
@@ -2139,24 +1455,19 @@
 msgstr "委托给数据库（JDBC）事务（默认）"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.transaction.JTATransactionFactory</literal>"
-msgstr "org.hibernate.transaction.JTATransactionFactory"
+msgstr "<literal>org.hibernate.transaction.JTATransactionFactory</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"delegates to container-managed transactions if an existing transaction is "
-"underway in this context (for example, EJB session bean method). Otherwise, "
-"a new transaction is started and bean-managed transactions are used."
-msgstr ""
-"如果在上下文环境中存在运行着的事务（如，EJB 会话 Bean 的方法），则委托给容器"
-"管理的事务。否则，将启动一个新的事务，并使用 Bean 管理的事务。"
+msgid "delegates to container-managed transactions if an existing transaction is underway in this context (for example, EJB session bean method). Otherwise, a new transaction is started and bean-managed transactions are used."
+msgstr "如果在上下文环境中存在运行着的事务（如，EJB 会话 Bean 的方法），则委托给容器管理的事务。否则，将启动一个新的事务，并使用 Bean 管理的事务。"
 
 #. Tag: term
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>org.hibernate.transaction.CMTTransactionFactory</literal>"
-msgstr "org.hibernate.transaction.CMTTransactionFactory"
+msgstr "<literal>org.hibernate.transaction.CMTTransactionFactory</literal>"
 
 #. Tag: para
 #, no-c-format
@@ -2165,25 +1476,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can also define your own transaction strategies (for a CORBA transaction "
-"service, for example)."
+msgid "You can also define your own transaction strategies (for a CORBA transaction service, for example)."
 msgstr "ä½ ä¹Ÿå¯ä»¥å®šä¹‰å±žäºŽä½ è‡ªå·±çš„äº‹åŠ¡ç­–ç•¥ï¼ˆå¦‚ï¼Œé’ˆå¯¹ CORBA 的事务服务）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Some features in Hibernate (i.e., the second level cache, Contextual "
-"Sessions with JTA, etc.) require access to the JTA "
-"<literal>TransactionManager</literal> in a managed environment. In an "
-"application server, since J2EE does not standardize a single mechanism, you "
-"have to specify how Hibernate should obtain a reference to the "
-"<literal>TransactionManager</literal>:"
-msgstr ""
-"Hibernate 的一些特性（比如二级缓存，Contextual Sessions with JTA 等等）需要访"
-"问在托管环境中的 JTA <literal>TransactionManager</literal>。由于 J2EE æ²¡æœ‰æ ‡"
-"准化一个单一的机制，Hibernate åœ¨åº”ç”¨ç¨‹åºæœåŠ¡å™¨ä¸­ï¼Œä½ å¿…é¡»æŒ‡å®š Hibernate 如何获"
-"得 <literal>TransactionManager</literal> 的引用： "
+msgid "Some features in Hibernate (i.e., the second level cache, Contextual Sessions with JTA, etc.) require access to the JTA <literal>TransactionManager</literal> in a managed environment. In an application server, since J2EE does not standardize a single mechanism, you have to specify how Hibernate should obtain a reference to the <literal>TransactionManager</literal>:"
+msgstr "Hibernate 的一些特性（比如二级缓存，Contextual Sessions with JTA 等等）需要访问在托管环境中的 JTA <literal>TransactionManager</literal>。由于 J2EE æ²¡æœ‰æ ‡å‡†åŒ–ä¸€ä¸ªå•ä¸€çš„æœºåˆ¶ï¼ŒHibernate åœ¨åº”ç”¨ç¨‹åºæœåŠ¡å™¨ä¸­ï¼Œä½ å¿…é¡»æŒ‡å®š Hibernate 如何获得 <literal>TransactionManager</literal> 的引用： "
 
 #. Tag: title
 #, no-c-format
@@ -2201,10 +1500,9 @@
 msgstr "应用程序服务器"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. JBossTransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.JBossTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. JBossTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. JBossTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2212,11 +1510,9 @@
 msgstr "JBoss"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. WeblogicTransactionManagerLookup</"
-"literal>"
-msgstr "org.hibernate.transaction.WeblogicTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. WeblogicTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. WeblogicTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2224,11 +1520,9 @@
 msgstr "Weblogic"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. WebSphereTransactionManagerLookup</"
-"literal>"
-msgstr "org.hibernate.transaction.WebSphereTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. WebSphereTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. WebSphereTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2236,11 +1530,9 @@
 msgstr "WebSphere"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. WebSphereExtendedJTATransactionLookup</"
-"literal>"
-msgstr "org.hibernate.transaction.WebSphereExtendedJTATransactionLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. WebSphereExtendedJTATransactionLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. WebSphereExtendedJTATransactionLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2248,10 +1540,9 @@
 msgstr "WebSphere 6"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. OrionTransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.OrionTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. OrionTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. OrionTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2259,10 +1550,9 @@
 msgstr "Orion"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. ResinTransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.ResinTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. ResinTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. ResinTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2270,10 +1560,9 @@
 msgstr "Resin"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. JOTMTransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.JOTMTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. JOTMTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. JOTMTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2281,10 +1570,9 @@
 msgstr "JOTM"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. JOnASTransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.JOnASTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. JOnASTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. JOnASTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2292,10 +1580,9 @@
 msgstr "JOnAS"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. JRun4TransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.JRun4TransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. JRun4TransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. JRun4TransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2303,10 +1590,9 @@
 msgstr "JRun4"
 
 #. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>org.hibernate.transaction. BESTransactionManagerLookup</literal>"
-msgstr "org.hibernate.transaction.BESTransactionManagerLookup"
+#, no-c-format
+msgid "<literal>org.hibernate.transaction. BESTransactionManagerLookup</literal>"
+msgstr "<literal>org.hibernate.transaction. BESTransactionManagerLookup</literal>"
 
 #. Tag: entry
 #, no-c-format
@@ -2320,87 +1606,33 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A JNDI-bound Hibernate <literal>SessionFactory</literal> can simplify the "
-"lookup function of the factory and create new <literal>Session</literal>s. "
-"This is not, however, related to a JNDI bound <literal>Datasource</literal>; "
-"both simply use the same registry."
-msgstr ""
-"与 JNDI 绑定的 Hibernate 的 <literal>SessionFactory</literal> 能简化工厂的查"
-"询，简化创建新的 <literal>Session</literal>。需要注意的是这与 JNDI 绑定 "
-"<literal>Datasource</literal> 没有关系，它们只是恰巧用了相同的注册表。"
+msgid "A JNDI-bound Hibernate <literal>SessionFactory</literal> can simplify the lookup function of the factory and create new <literal>Session</literal>s. This is not, however, related to a JNDI bound <literal>Datasource</literal>; both simply use the same registry."
+msgstr "与 JNDI 绑定的 Hibernate 的 <literal>SessionFactory</literal> 能简化工厂的查询，简化创建新的 <literal>Session</literal>。需要注意的是这与 JNDI 绑定 <literal>Datasource</literal> 没有关系，它们只是恰巧用了相同的注册表。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you wish to have the <literal>SessionFactory</literal> bound to a JNDI "
-"namespace, specify a name (e.g. <literal>java:hibernate/SessionFactory</"
-"literal>) using the property <literal>hibernate.session_factory_name</"
-"literal>. If this property is omitted, the <literal>SessionFactory</literal> "
-"will not be bound to JNDI. This is especially useful in environments with a "
-"read-only JNDI default implementation (in Tomcat, for example)."
-msgstr ""
-"å¦‚æžœä½ å¸Œæœ›å°† <literal>SessionFactory</literal> 绑定到一个 JNDI 的名字空间，用"
-"属性 <literal>hibernate.session_factory_name</literal> 指定一个名字（如，"
-"<literal>java：hibernate/SessionFactory</literal>）。如果不设置这个属性，"
-"<literal>SessionFactory</literal> 将不会被绑定到 JNDI 中（在以只读 JNDI 为默"
-"认实现的环境中，这个设置尤其有用，如 Tomcat）。"
+msgid "If you wish to have the <literal>SessionFactory</literal> bound to a JNDI namespace, specify a name (e.g. <literal>java:hibernate/SessionFactory</literal>) using the property <literal>hibernate.session_factory_name</literal>. If this property is omitted, the <literal>SessionFactory</literal> will not be bound to JNDI. This is especially useful in environments with a read-only JNDI default implementation (in Tomcat, for example)."
+msgstr "å¦‚æžœä½ å¸Œæœ›å°† <literal>SessionFactory</literal> 绑定到一个 JNDI 的名字空间，用属性 <literal>hibernate.session_factory_name</literal> 指定一个名字（如，<literal>java：hibernate/SessionFactory</literal>）。如果不设置这个属性，<literal>SessionFactory</literal> 将不会被绑定到 JNDI 中（在以只读 JNDI 为默认实现的环境中，这个设置尤其有用，如 Tomcat）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will "
-"use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate."
-"jndi.class</literal> to instantiate an initial context. If they are not "
-"specified, the default <literal>InitialContext</literal> will be used."
-msgstr ""
-"在将 <literal>SessionFactory</literal> 绑定至 JNDI 时，Hibernate 将使用 "
-"<literal>hibernate.jndi.url</literal>，和 <literal>hibernate.jndi.class</"
-"literal> 的值来实例化初始环境（initial context）。如果它们没有被指定，将使用"
-"默认的 <literal>InitialContext</literal>。"
+msgid "When binding the <literal>SessionFactory</literal> to JNDI, Hibernate will use the values of <literal>hibernate.jndi.url</literal>, <literal>hibernate.jndi.class</literal> to instantiate an initial context. If they are not specified, the default <literal>InitialContext</literal> will be used."
+msgstr "在将 <literal>SessionFactory</literal> 绑定至 JNDI 时，Hibernate 将使用 <literal>hibernate.jndi.url</literal>，和 <literal>hibernate.jndi.class</literal> 的值来实例化初始环境（initial context）。如果它们没有被指定，将使用默认的 <literal>InitialContext</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate will automatically place the <literal>SessionFactory</literal> in "
-"JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means "
-"you will have this call in some startup code, or utility class in your "
-"application, unless you use JMX deployment with the "
-"<literal>HibernateService</literal> (this is discussed later in greater "
-"detail)."
-msgstr ""
-"åœ¨ä½ è°ƒç”¨ <literal>cfg.buildSessionFactory()</literal>后，Hibernate 会自动将 "
-"<literal>SessionFactory</literal> 注册到 JNDIã€‚è¿™æ„å‘³è¿™ä½ è‡³å°‘éœ€è¦åœ¨ä½ åº”ç”¨ç¨‹åº"
-"çš„å¯åŠ¨ä»£ç ï¼ˆæˆ–å·¥å…·ç±»ï¼‰ä¸­å®Œæˆè¿™ä¸ªè°ƒç”¨ï¼Œé™¤éžä½ ä½¿ç”¨ <literal>HibernateService</"
-"literal> 来做 JMX 部署（见后面讨论）。"
+msgid "Hibernate will automatically place the <literal>SessionFactory</literal> in JNDI after you call <literal>cfg.buildSessionFactory()</literal>. This means you will have this call in some startup code, or utility class in your application, unless you use JMX deployment with the <literal>HibernateService</literal> (this is discussed later in greater detail)."
+msgstr "åœ¨ä½ è°ƒç”¨ <literal>cfg.buildSessionFactory()</literal>后，Hibernate 会自动将 <literal>SessionFactory</literal> 注册到 JNDIã€‚è¿™æ„å‘³è¿™ä½ è‡³å°‘éœ€è¦åœ¨ä½ åº”ç”¨ç¨‹åºçš„å¯åŠ¨ä»£ç ï¼ˆæˆ–å·¥å…·ç±»ï¼‰ä¸­å®Œæˆè¿™ä¸ªè°ƒç”¨ï¼Œé™¤éžä½ ä½¿ç”¨ <literal>HibernateService</literal> 来做 JMX 部署（见后面讨论）。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other "
-"class, you can obtain the <literal>SessionFactory</literal> using a JNDI "
-"lookup."
-msgstr ""
-"å‡è‹¥ä½ ä½¿ç”¨ JNDI <literal>SessionFactory</literal>，EJB 或者任何其它类都可以"
-"从 JNDI 中找到此 <literal>SessionFactory</literal>。 "
+msgid "If you use a JNDI <literal>SessionFactory</literal>, an EJB or any other class, you can obtain the <literal>SessionFactory</literal> using a JNDI lookup."
+msgstr "å‡è‹¥ä½ ä½¿ç”¨ JNDI <literal>SessionFactory</literal>，EJB 或者任何其它类都可以从 JNDI 中找到此 <literal>SessionFactory</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is recommended that you bind the <literal>SessionFactory</literal> to "
-"JNDI in a managed environment and use a <literal>static</literal> singleton "
-"otherwise. To shield your application code from these details, we also "
-"recommend to hide the actual lookup code for a <literal>SessionFactory</"
-"literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory"
-"()</literal>. Note that such a class is also a convenient way to startup "
-"Hibernate&mdash;see chapter 1."
-msgstr ""
-"我们建议，在受管理的环境中，把 <literal>SessionFactory</literal> 绑定到 "
-"JNDI，在其它情况下，使用一个 <literal>static（静态的）</literal>singleton。为"
-"äº†åœ¨ä½ çš„åº”ç”¨ç¨‹åºä»£ç ä¸­éšè—è¿™äº›ç»†èŠ‚ï¼Œæˆ‘ä»¬è¿˜å»ºè®®ä½ ç”¨ä¸€ä¸ª helper 类把实际查找 "
-"<literal>SessionFactory</literal> çš„ä»£ç éšè—èµ·æ¥ï¼Œæ¯”å¦‚ "
-"<literal>HibernateUtil.getSessionFactory()</literal>。注意，这个类也就可以方"
-"便地启动 Hibernateï¼Œå‚è§ç¬¬ä¸€ç« ã€‚ "
+msgid "It is recommended that you bind the <literal>SessionFactory</literal> to JNDI in a managed environment and use a <literal>static</literal> singleton otherwise. To shield your application code from these details, we also recommend to hide the actual lookup code for a <literal>SessionFactory</literal> in a helper class, such as <literal>HibernateUtil.getSessionFactory()</literal>. Note that such a class is also a convenient way to startup Hibernate&mdash;see chapter 1."
+msgstr "我们建议，在受管理的环境中，把 <literal>SessionFactory</literal> 绑定到 JNDI，在其它情况下，使用一个 <literal>static（静态的）</literal>singletonã€‚ä¸ºäº†åœ¨ä½ çš„åº”ç”¨ç¨‹åºä»£ç ä¸­éšè—è¿™äº›ç»†èŠ‚ï¼Œæˆ‘ä»¬è¿˜å»ºè®®ä½ ç”¨ä¸€ä¸ª helper 类把实际查找 <literal>SessionFactory</literal> çš„ä»£ç éšè—èµ·æ¥ï¼Œæ¯”å¦‚ <literal>HibernateUtil.getSessionFactory()</literal>。注意，这个类也就可以方便地启动 Hibernateï¼Œå‚è§ç¬¬ä¸€ç« ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -2408,43 +1640,9 @@
 msgstr "在 JTA 环境下使用 Current Session context（当前 session 上下文）管理"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The easiest way to handle <literal>Sessions</literal> and transactions is "
-"Hibernate's automatic \"current\" <literal>Session</literal> management. For "
-"a discussion of contextual sessions see <xref linkend=\"architecture-current-"
-"session\" />. Using the <literal>\"jta\"</literal> session context, if there "
-"is no Hibernate <literal>Session</literal> associated with the current JTA "
-"transaction, one will be started and associated with that JTA transaction "
-"the first time you call <literal>sessionFactory.getCurrentSession()</"
-"literal>. The <literal>Session</literal>s retrieved via "
-"<literal>getCurrentSession()</literal> in the<literal>\"jta\"</literal> "
-"context are set to automatically flush before the transaction completes, "
-"close after the transaction completes, and aggressively release JDBC "
-"connections after each statement. This allows the <literal>Session</"
-"literal>s to be managed by the life cycle of the JTA transaction to which it "
-"is associated, keeping user code clean of such management concerns. Your "
-"code can either use JTA programmatically through <literal>UserTransaction</"
-"literal>, or (recommended for portable code) use the Hibernate "
-"<literal>Transaction</literal> API to set transaction boundaries. If you run "
-"in an EJB container, declarative transaction demarcation with CMT is "
-"preferred."
-msgstr ""
-"在 Hibernate 中，管理 <literal>Session</literal> 和 transaction 最好的方法是"
-"自动的\"当前\"<literal>Session</literal> 管理。请参见 <xref linkend="
-"\"architecture-current-session\">contextual sessions</xref> 一节的讨论。使用 "
-"<literal>\"jta\"</literal> session 上下文，假若在当前 JTA 事务中还没有 "
-"Hibernate<literal>Session</literal> 关联，第一次 <literal>sessionFactory."
-"getCurrentSession()</literal> 调用会启动一个 Session，并关联到当前的 JTA 事"
-"务。在 <literal>\"jta\"</literal> 上下文中调用 <literal>getCurrentSession()</"
-"literal> 获得的 <literal>Session</literal>，会被设置为在 transaction 关闭的时"
-"候自动 flush（清洗）、在 transaction 关闭之后自动关闭，每句语句之后主动释放 "
-"JDBC è¿žæŽ¥ã€‚è¿™å°±å¯ä»¥æ ¹æ® JTA 事务的生命周期来管理与之关联的 <literal>Session</"
-"literal>ï¼Œç”¨æˆ·ä»£ç ä¸­å°±å¯ä»¥ä¸å†è€ƒè™‘è¿™äº›ç®¡ç†ã€‚ä½ çš„ä»£ç ä¹Ÿå¯ä»¥é€šè¿‡ "
-"<literal>UserTransaction</literal>用编程方式使用 JTA，或者（我们建议，为了便"
-"äºŽç§»æ¤ä»£ç ï¼‰ä½¿ç”¨ Hibernate çš„ <literal>Transaction</literal> API 来设置 "
-"transaction è¾¹ç•Œã€‚å¦‚æžœä½ çš„ä»£ç è¿è¡Œåœ¨ EJB 容器中，我们建议对 CMT 使用声明式事"
-"务声明。"
+#, no-c-format
+msgid "The easiest way to handle <literal>Sessions</literal> and transactions is Hibernate's automatic \"current\" <literal>Session</literal> management. For a discussion of contextual sessions see <xref linkend=\"architecture-current-session\" />. Using the <literal>\"jta\"</literal> session context, if there is no Hibernate <literal>Session</literal> associated with the current JTA transaction, one will be started and associated with that JTA transaction the first time you call <literal>sessionFactory.getCurrentSession()</literal>. The <literal>Session</literal>s retrieved via <literal>getCurrentSession()</literal> in the<literal>\"jta\"</literal> context are set to automatically flush before the transaction completes, close after the transaction completes, and aggressively release JDBC connections after each statement. This allows the <literal>Session</literal>s to be managed by the life cycle of the JTA transaction to which it is associated, keeping user code clean of s!
 uch management concerns. Your code can either use JTA programmatically through <literal>UserTransaction</literal>, or (recommended for portable code) use the Hibernate <literal>Transaction</literal> API to set transaction boundaries. If you run in an EJB container, declarative transaction demarcation with CMT is preferred."
+msgstr "在 Hibernate 中，管理 <literal>Session</literal> å’Œ transaction 最好的方法是自动的\"当前\"<literal>Session</literal> 管理。请参见 <xref linkend=\"architecture-current-session\">contextual sessions</xref> 一节的讨论。使用 <literal>\"jta\"</literal> session 上下文，假若在当前 JTA 事务中还没有 Hibernate<literal>Session</literal> 关联，第一次 <literal>sessionFactory.getCurrentSession()</literal> 调用会启动一个 Session，并关联到当前的 JTA 事务。在 <literal>\"jta\"</literal> 上下文中调用 <literal>getCurrentSession()</literal> 获得的 <literal>Session</literal>，会被设置为在 transaction 关闭的时候自动 flush（清洗）、在 transaction 关闭之后自动关闭，每句语句之后主动释放 JDBC è¿žæŽ¥ã€‚è¿™å°±å¯ä»¥æ ¹æ® JTA 事务的生命周期来管理与之关联的 <literal>Session</literal>ï¼Œç”¨æˆ·ä»£ç ä¸­å°±å¯ä»¥ä¸å†è€ƒè™‘è¿™äº›ç®¡ç†ã€‚ä½ çš„ä»£ç ä¹Ÿå¯ä»¥é€šè¿‡ !
 <literal>UserTransaction</literal>用编程方式使用 JTAï¼Œæˆ–è€…ï¼ˆæˆ‘ä»¬å»ºè®®ï¼Œä¸ºäº†ä¾¿äºŽç§»æ¤ä»£ç ï¼‰ä½¿ç”¨ Hibernate çš„ <literal>Transaction</literal> API 来设置 transaction è¾¹ç•Œã€‚å¦‚æžœä½ çš„ä»£ç è¿è¡Œåœ¨ EJB 容器中，我们建议对 CMT 使用声明式事务声明。 "
 
 #. Tag: title
 #, no-c-format
@@ -2453,50 +1651,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The line <literal>cfg.buildSessionFactory()</literal> still has to be "
-"executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You "
-"can do this either in a <literal>static</literal> initializer block, like "
-"the one in <literal>HibernateUtil</literal>, or you can deploy Hibernate as "
-"a <emphasis>managed service</emphasis>."
-msgstr ""
-"为了将 <literal>SessionFactory</literal> 注册到 JNDI 中，<literal>cfg."
-"buildSessionFactory()</literal> è¿™è¡Œä»£ç ä»éœ€åœ¨æŸå¤„è¢«æ‰§è¡Œã€‚ä½ å¯åœ¨ä¸€ä¸ª "
-"<literal>static</literal> 初始化块（像 <literal>HibernateUtil</literal> 中的"
-"é‚£æ ·ï¼‰ä¸­æ‰§è¡Œå®ƒæˆ–å°† Hibernate 部署为一个<emphasis>托管的服务</emphasis>。  "
+msgid "The line <literal>cfg.buildSessionFactory()</literal> still has to be executed somewhere to get a <literal>SessionFactory</literal> into JNDI. You can do this either in a <literal>static</literal> initializer block, like the one in <literal>HibernateUtil</literal>, or you can deploy Hibernate as a <emphasis>managed service</emphasis>."
+msgstr "为了将 <literal>SessionFactory</literal> 注册到 JNDI 中，<literal>cfg.buildSessionFactory()</literal> è¿™è¡Œä»£ç ä»éœ€åœ¨æŸå¤„è¢«æ‰§è¡Œã€‚ä½ å¯åœ¨ä¸€ä¸ª <literal>static</literal> 初始化块（像 <literal>HibernateUtil</literal> ä¸­çš„é‚£æ ·ï¼‰ä¸­æ‰§è¡Œå®ƒæˆ–å°† Hibernate 部署为一个<emphasis>托管的服务</emphasis>。  "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</"
-"literal> for deployment on an application server with JMX capabilities, such "
-"as JBoss AS. The actual deployment and configuration is vendor-specific. "
-"Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
-msgstr ""
-"为了部署在一个支持 JMX 的应用程序服务器上，Hibernate 和 <literal>org."
-"hibernate.jmx.HibernateService</literal> 一同分发，如 Jboss AS。 实际的部署和"
-"配置是由应用程序服务器提供者指定的。这里是 JBoss 4.0.x 的 <literal>jboss-"
-"service.xml</literal> æ ·ä¾‹ï¼š "
+msgid "Hibernate is distributed with <literal>org.hibernate.jmx.HibernateService</literal> for deployment on an application server with JMX capabilities, such as JBoss AS. The actual deployment and configuration is vendor-specific. Here is an example <literal>jboss-service.xml</literal> for JBoss 4.0.x:"
+msgstr "为了部署在一个支持 JMX 的应用程序服务器上，Hibernate å’Œ <literal>org.hibernate.jmx.HibernateService</literal> 一同分发，如 Jboss AS。 实际的部署和配置是由应用程序服务器提供者指定的。这里是 JBoss 4.0.x çš„ <literal>jboss-service.xml</literal> æ ·ä¾‹ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This file is deployed in a directory called <literal>META-INF</literal> and "
-"packaged in a JAR file with the extension <literal>.sar</literal> (service "
-"archive). You also need to package Hibernate, its required third-party "
-"libraries, your compiled persistent classes, as well as your mapping files "
-"in the same archive. Your enterprise beans (usually session beans) can be "
-"kept in their own JAR file, but you can include this EJB JAR file in the "
-"main service archive to get a single (hot-)deployable unit. Consult the "
-"JBoss AS documentation for more information about JMX service and EJB "
-"deployment."
-msgstr ""
-"这个文件是部署在 <literal>META-INF</literal> 目录下的，并会被打包到以 "
-"<literal>.sar</literal>（service archive）为扩展名的 JAR æ–‡ä»¶ä¸­ã€‚åŒæ—¶ï¼Œä½ éœ€è¦"
-"å°† Hibernateã€å®ƒæ‰€éœ€è¦çš„ç¬¬ä¸‰æ–¹åº“ã€ä½ ç¼–è¯‘å¥½çš„æŒä¹…åŒ–ç±»ä»¥åŠä½ çš„æ˜ å°„å®šä¹‰æ–‡ä»¶æ‰“åŒ…"
-"è¿›åŒä¸€ä¸ªæ–‡æ¡£ã€‚ä½ çš„ä¼ä¸š Bean（一般为会话 Bean）可能会被打包成它们自己的 JAR æ–‡"
-"ä»¶ï¼Œä½†ä½ ä¹Ÿè®¸ä¼šå°† EJB JAR 文件一同包含进能独立（热）部署的主服务文档。参考 "
-"JBoss AS 文档以了解更多的 JMX服务与 EJB 部署的信息。 "
+msgid "This file is deployed in a directory called <literal>META-INF</literal> and packaged in a JAR file with the extension <literal>.sar</literal> (service archive). You also need to package Hibernate, its required third-party libraries, your compiled persistent classes, as well as your mapping files in the same archive. Your enterprise beans (usually session beans) can be kept in their own JAR file, but you can include this EJB JAR file in the main service archive to get a single (hot-)deployable unit. Consult the JBoss AS documentation for more information about JMX service and EJB deployment."
+msgstr "这个文件是部署在 <literal>META-INF</literal> 目录下的，并会被打包到以 <literal>.sar</literal>（service archive）为扩展名的 JAR æ–‡ä»¶ä¸­ã€‚åŒæ—¶ï¼Œä½ éœ€è¦å°† Hibernateã€å®ƒæ‰€éœ€è¦çš„ç¬¬ä¸‰æ–¹åº“ã€ä½ ç¼–è¯‘å¥½çš„æŒä¹…åŒ–ç±»ä»¥åŠä½ çš„æ˜ å°„å®šä¹‰æ–‡ä»¶æ‰“åŒ…è¿›åŒä¸€ä¸ªæ–‡æ¡£ã€‚ä½ çš„ä¼ä¸š Bean（一般为会话 Bean）可能会被打包成它们自己的 JAR æ–‡ä»¶ï¼Œä½†ä½ ä¹Ÿè®¸ä¼šå°† EJB JAR 文件一同包含进能独立（热）部署的主服务文档。参考 JBoss AS 文档以了解更多的 JMX服务与 EJB 部署的信息。 "
 
 #~ msgid ""
 #~ "<![CDATA[Configuration cfg = new Configuration()\n"
@@ -2506,7 +1672,6 @@
 #~ "<![CDATA[Configuration cfg = new Configuration()\n"
 #~ "    .addResource(\"Item.hbm.xml\")\n"
 #~ "    .addResource(\"Bid.hbm.xml\");]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Configuration cfg = new Configuration()\n"
 #~ "    .addClass(org.hibernate.auction.Item.class)\n"
@@ -2515,7 +1680,6 @@
 #~ "<![CDATA[Configuration cfg = new Configuration()\n"
 #~ "    .addClass(org.hibernate.auction.Item.class)\n"
 #~ "    .addClass(org.hibernate.auction.Bid.class);]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Configuration cfg = new Configuration()\n"
 #~ "    .addClass(org.hibernate.auction.Item.class)\n"
@@ -2534,26 +1698,20 @@
 #~ "    .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/"
 #~ "jdbc/test\")\n"
 #~ "    .setProperty(\"hibernate.order_updates\", \"true\");]]>"
-
 #~ msgid "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
 #~ msgstr "<![CDATA[SessionFactory sessions = cfg.buildSessionFactory();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Session session = sessions.openSession(); // open a new Session]]"
 #~ ">"
 #~ msgstr ""
 #~ "<![CDATA[Session session = sessions.openSession(); // open a new Session]]"
 #~ ">"
-
 #~ msgid "JDBC URL"
 #~ msgstr "JDBC URL"
-
 #~ msgid "database user"
 #~ msgstr "database user"
-
 #~ msgid "database user password"
 #~ msgstr "æ•°æ®åº“ç”¨æˆ·å¯†ç "
-
 #~ msgid ""
 #~ "<![CDATA[hibernate.connection.driver_class = org.postgresql.Driver\n"
 #~ "hibernate.connection.url = jdbc:postgresql://localhost/mydatabase\n"
@@ -2574,10 +1732,8 @@
 #~ "hibernate.c3p0.timeout=1800\n"
 #~ "hibernate.c3p0.max_statements=50\n"
 #~ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
-
 #~ msgid "datasource JNDI name"
 #~ msgstr "数据源 JNDI 名字"
-
 #~ msgid ""
 #~ "<![CDATA[hibernate.connection.datasource = java:/comp/env/jdbc/test\n"
 #~ "hibernate.transaction.factory_class = \\\n"
@@ -2592,19 +1748,14 @@
 #~ "hibernate.transaction.manager_lookup_class = \\\n"
 #~ "    org.hibernate.transaction.JBossTransactionManagerLookup\n"
 #~ "hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect]]>"
-
 #~ msgid "<entry>DB2</entry>"
 #~ msgstr "<entry>DB2</entry>"
-
 #~ msgid "hibernate.query.substitutions true=1, false=0"
 #~ msgstr "hibernate.query.substitutions true=1，false=0"
-
 #~ msgid "hibernate.query.substitutions toLowercase=LOWER"
 #~ msgstr "hibernate.query.substitutions toLowercase=LOWER"
-
 #~ msgid "org.hibernate"
 #~ msgstr "org.hibernate"
-
 #~ msgid ""
 #~ "<![CDATA[SessionFactory sf = new Configuration()\n"
 #~ "    .setNamingStrategy(ImprovedNamingStrategy.INSTANCE)\n"
@@ -2617,7 +1768,6 @@
 #~ "    .addFile(\"Item.hbm.xml\")\n"
 #~ "    .addFile(\"Bid.hbm.xml\")\n"
 #~ "    .buildSessionFactory();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<?xml version='1.0' encoding='utf-8'?>\n"
 #~ "<!DOCTYPE hibernate-configuration PUBLIC\n"
@@ -2698,14 +1848,12 @@
 #~ "    </session-factory>\n"
 #~ "\n"
 #~ "</hibernate-configuration>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[SessionFactory sf = new Configuration().configure()."
 #~ "buildSessionFactory();]]>"
 #~ msgstr ""
 #~ "<![CDATA[SessionFactory sf = new Configuration().configure()."
 #~ "buildSessionFactory();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[SessionFactory sf = new Configuration()\n"
 #~ "    .configure(\"catdb.cfg.xml\")\n"
@@ -2714,7 +1862,6 @@
 #~ "<![CDATA[SessionFactory sf = new Configuration()\n"
 #~ "    .configure(\"catdb.cfg.xml\")\n"
 #~ "    .buildSessionFactory();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<?xml version=\"1.0\"?>\n"
 #~ "<server>\n"
@@ -2811,3 +1958,4 @@
 #~ "</mbean>\n"
 #~ "\n"
 #~ "</server>]]>"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/example_parentchild.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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: 2009-11-27 13:54+1000\n"
+"PO-Revision-Date: 2009-12-11 09:48+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -21,31 +21,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"One of the first things that new users want to do with Hibernate is to model "
-"a parent/child type relationship. There are two different approaches to "
-"this. The most convenient approach, especially for new users, is to model "
-"both <literal>Parent</literal> and <literal>Child</literal> as entity "
-"classes with a <literal>&lt;one-to-many&gt;</literal> association from "
-"<literal>Parent</literal> to <literal>Child</literal>. The alternative "
-"approach is to declare the <literal>Child</literal> as a <literal>&lt;"
-"composite-element&gt;</literal>. The default semantics of a one-to-many "
-"association in Hibernate are much less close to the usual semantics of a "
-"parent/child relationship than those of a composite element mapping. We will "
-"explain how to use a <emphasis>bidirectional one-to-many association with "
-"cascades</emphasis> to model a parent/child relationship efficiently and "
-"elegantly."
-msgstr ""
-"刚刚接触 Hibernate 的人大多是从父子关系（parent / child type relationship）的"
-"å»ºæ¨¡å…¥æ‰‹çš„ã€‚çˆ¶å­å…³ç³»çš„å»ºæ¨¡æœ‰ä¸¤ç§æ–¹æ³•ã€‚ç”±äºŽç§ç§åŽŸå› ï¼Œæœ€æ–¹ä¾¿çš„æ–¹æ³•æ˜¯æŠŠ "
-"<literal>Parent</literal> 和 <literal>Child</literal> 都建模成实体类，并创建"
-"一个从 <literal>Parent</literal> 指向 <literal>Child</literal> 的 &lt;one-to-"
-"many&gt; 关联，对新手来说尤其如此。还有一种方法，就是将 <literal>Child</"
-"literal> 声明为一个 <literal>&lt;composite-element&gt;</literal>（组合元"
-"ç´ ï¼‰ã€‚ 事实上在 Hibernate 中 one to many 关联的默认语义远没有 composite "
-"element 贴近 parent / child 关系的通常语义。下面我们会阐述如何使用<emphasis>"
-"带有级联的双向一对多关联（idirectional one to many association with "
-"cascades）</emphasis>去建立有效、优美的 parent / child 关系。"
+msgid "One of the first things that new users want to do with Hibernate is to model a parent/child type relationship. There are two different approaches to this. The most convenient approach, especially for new users, is to model both <literal>Parent</literal> and <literal>Child</literal> as entity classes with a <literal>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>. The alternative approach is to declare the <literal>Child</literal> as a <literal>&lt;composite-element&gt;</literal>. The default semantics of a one-to-many association in Hibernate are much less close to the usual semantics of a parent/child relationship than those of a composite element mapping. We will explain how to use a <emphasis>bidirectional one-to-many association with cascades</emphasis> to model a parent/child relationship efficiently and elegantly."
+msgstr "刚刚接触 Hibernate 的人大多是从父子关系（parent / child type relationshipï¼‰çš„å»ºæ¨¡å…¥æ‰‹çš„ã€‚çˆ¶å­å…³ç³»çš„å»ºæ¨¡æœ‰ä¸¤ç§æ–¹æ³•ã€‚ç”±äºŽç§ç§åŽŸå› ï¼Œæœ€æ–¹ä¾¿çš„æ–¹æ³•æ˜¯æŠŠ <literal>Parent</literal> å’Œ <literal>Child</literal> 都建模成实体类，并创建一个从 <literal>Parent</literal> 指向 <literal>Child</literal> çš„ &lt;one-to-many&gt; 关联，对新手来说尤其如此。还有一种方法，就是将 <literal>Child</literal> 声明为一个 <literal>&lt;composite-element&gt;</literal>ï¼ˆç»„åˆå…ƒç´ ï¼‰ã€‚ 事实上在 Hibernate 中 one to many 关联的默认语义远没有 composite element è´´è¿‘ parent / child 关系的通常语义。下面我们会阐述如何使用<emphasis>带有级联的双向一对多关联（idirectional one to many association with cascades）</emphasis>去建立有效、优美的 parent / child 关系。"
 
 #. Tag: title
 #, no-c-format
@@ -54,62 +31,28 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate collections are considered to be a logical part of their owning "
-"entity and not of the contained entities. Be aware that this is a critical "
-"distinction that has the following consequences:"
-msgstr ""
-"Hibernate collections 被当作其所属实体而不是其包含实体的一个逻辑部分。这非常"
-"é‡è¦ï¼Œå®ƒä¸»è¦ä½“çŽ°ä¸ºä»¥ä¸‹å‡ ç‚¹ï¼š"
+msgid "Hibernate collections are considered to be a logical part of their owning entity and not of the contained entities. Be aware that this is a critical distinction that has the following consequences:"
+msgstr "Hibernate collections è¢«å½“ä½œå…¶æ‰€å±žå®žä½“è€Œä¸æ˜¯å…¶åŒ…å«å®žä½“çš„ä¸€ä¸ªé€»è¾‘éƒ¨åˆ†ã€‚è¿™éžå¸¸é‡è¦ï¼Œå®ƒä¸»è¦ä½“çŽ°ä¸ºä»¥ä¸‹å‡ ç‚¹ï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"When you remove/add an object from/to a collection, the version number of "
-"the collection owner is incremented."
-msgstr ""
-"å½“åˆ é™¤æˆ–å¢žåŠ  collection 中对象的时候，collection 所属者的版本值会递增。 "
+msgid "When you remove/add an object from/to a collection, the version number of the collection owner is incremented."
+msgstr "å½“åˆ é™¤æˆ–å¢žåŠ  collection 中对象的时候，collection 所属者的版本值会递增。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If an object that was removed from a collection is an instance of a value "
-"type (e.g. a composite element), that object will cease to be persistent and "
-"its state will be completely removed from the database. Likewise, adding a "
-"value type instance to the collection will cause its state to be immediately "
-"persistent."
-msgstr ""
-"如果一个从 collection 中移除的对象是一个值类型（value type）的实例，比如 "
-"composite element，那么这个对象的持久化状态将会终止，其在数据库中对应的记录会"
-"è¢«åˆ é™¤ã€‚åŒæ ·çš„ï¼Œå‘ collection å¢žåŠ ä¸€ä¸ª value type 的实例将会使之立即被持久"
-"化。 "
+msgid "If an object that was removed from a collection is an instance of a value type (e.g. a composite element), that object will cease to be persistent and its state will be completely removed from the database. Likewise, adding a value type instance to the collection will cause its state to be immediately persistent."
+msgstr "如果一个从 collection 中移除的对象是一个值类型（value type）的实例，比如 composite elementï¼Œé‚£ä¹ˆè¿™ä¸ªå¯¹è±¡çš„æŒä¹…åŒ–çŠ¶æ€å°†ä¼šç»ˆæ­¢ï¼Œå…¶åœ¨æ•°æ®åº“ä¸­å¯¹åº”çš„è®°å½•ä¼šè¢«åˆ é™¤ã€‚åŒæ ·çš„ï¼Œå‘ collection å¢žåŠ ä¸€ä¸ª value type 的实例将会使之立即被持久化。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Conversely, if an entity is removed from a collection (a one-to-many or many-"
-"to-many association), it will not be deleted by default. This behavior is "
-"completely consistent; a change to the internal state of another entity "
-"should not cause the associated entity to vanish. Likewise, adding an entity "
-"to a collection does not cause that entity to become persistent, by default."
-msgstr ""
-"另一方面，如果从一对多或多对多关联的 collection 中移除一个实体，在缺省情况下"
-"è¿™ä¸ªå¯¹è±¡å¹¶ä¸ä¼šè¢«åˆ é™¤ã€‚è¿™ä¸ªè¡Œä¸ºæ˜¯å®Œå…¨åˆä¹Žé€»è¾‘çš„ï¼ï¼æ”¹å˜ä¸€ä¸ªå®žä½“çš„å†…éƒ¨çŠ¶æ€ä¸åº”"
-"è¯¥ä½¿ä¸Žå®ƒå…³è”çš„å®žä½“æ¶ˆå¤±æŽ‰ã€‚åŒæ ·çš„ï¼Œå‘ collection å¢žåŠ ä¸€ä¸ªå®žä½“ä¸ä¼šä½¿ä¹‹è¢«æŒä¹…"
-"化。 "
+msgid "Conversely, if an entity is removed from a collection (a one-to-many or many-to-many association), it will not be deleted by default. This behavior is completely consistent; a change to the internal state of another entity should not cause the associated entity to vanish. Likewise, adding an entity to a collection does not cause that entity to become persistent, by default."
+msgstr "另一方面，如果从一对多或多对多关联的 collection ä¸­ç§»é™¤ä¸€ä¸ªå®žä½“ï¼Œåœ¨ç¼ºçœæƒ…å†µä¸‹è¿™ä¸ªå¯¹è±¡å¹¶ä¸ä¼šè¢«åˆ é™¤ã€‚è¿™ä¸ªè¡Œä¸ºæ˜¯å®Œå…¨åˆä¹Žé€»è¾‘çš„ï¼ï¼æ”¹å˜ä¸€ä¸ªå®žä½“çš„å†…éƒ¨çŠ¶æ€ä¸åº”è¯¥ä½¿ä¸Žå®ƒå…³è”çš„å®žä½“æ¶ˆå¤±æŽ‰ã€‚åŒæ ·çš„ï¼Œå‘ collection å¢žåŠ ä¸€ä¸ªå®žä½“ä¸ä¼šä½¿ä¹‹è¢«æŒä¹…åŒ–ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Adding an entity to a collection, by default, merely creates a link between "
-"the two entities. Removing the entity will remove the link. This is "
-"appropriate for all sorts of cases. However, it is not appropriate in the "
-"case of a parent/child relationship. In this case, the life of the child is "
-"bound to the life cycle of the parent."
-msgstr ""
-"实际上，向 Collection å¢žåŠ ä¸€ä¸ªå®žä½“çš„ç¼ºçœåŠ¨ä½œåªæ˜¯åœ¨ä¸¤ä¸ªå®žä½“ä¹‹é—´åˆ›å»ºä¸€ä¸ªè¿žæŽ¥è€Œ"
-"å·²ï¼ŒåŒæ ·ç§»é™¤çš„æ—¶å€™ä¹Ÿåªæ˜¯åˆ é™¤è¿žæŽ¥ã€‚è¿™ç§å¤„ç†å¯¹äºŽæ‰€æœ‰çš„æƒ…å†µéƒ½æ˜¯åˆé€‚çš„ã€‚å¯¹äºŽçˆ¶å­"
-"关系则是完全不适合的，在这种关系下，子对象的生存绑定于父对象的生存周期。 "
+msgid "Adding an entity to a collection, by default, merely creates a link between the two entities. Removing the entity will remove the link. This is appropriate for all sorts of cases. However, it is not appropriate in the case of a parent/child relationship. In this case, the life of the child is bound to the life cycle of the parent."
+msgstr "实际上，向 Collection å¢žåŠ ä¸€ä¸ªå®žä½“çš„ç¼ºçœåŠ¨ä½œåªæ˜¯åœ¨ä¸¤ä¸ªå®žä½“ä¹‹é—´åˆ›å»ºä¸€ä¸ªè¿žæŽ¥è€Œå·²ï¼ŒåŒæ ·ç§»é™¤çš„æ—¶å€™ä¹Ÿåªæ˜¯åˆ é™¤è¿žæŽ¥ã€‚è¿™ç§å¤„ç†å¯¹äºŽæ‰€æœ‰çš„æƒ…å†µéƒ½æ˜¯åˆé€‚çš„ã€‚å¯¹äºŽçˆ¶å­å…³ç³»åˆ™æ˜¯å®Œå…¨ä¸é€‚åˆçš„ï¼Œåœ¨è¿™ç§å…³ç³»ä¸‹ï¼Œå­å¯¹è±¡çš„ç”Ÿå­˜ç»‘å®šäºŽçˆ¶å¯¹è±¡çš„ç”Ÿå­˜å‘¨æœŸã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -118,11 +61,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Suppose we start with a simple <literal>&lt;one-to-many&gt;</literal> "
-"association from <literal>Parent</literal> to <literal>Child</literal>."
-msgstr ""
-"假设我们要实现一个简单的从 Parent 到 Child 的 &lt;one-to-many&gt; 关联。"
+msgid "Suppose we start with a simple <literal>&lt;one-to-many&gt;</literal> association from <literal>Parent</literal> to <literal>Child</literal>."
+msgstr "假设我们要实现一个简单的从 Parent 到 Child 的 &lt;one-to-many&gt; 关联。"
 
 #. Tag: para
 #, no-c-format
@@ -136,31 +76,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"an <literal>INSERT</literal> to create the record for <literal>c</literal>"
-msgstr ""
-"一条 <literal>INSERT</literal> 语句，为 <literal>c</literal> 创建一条记录"
+msgid "an <literal>INSERT</literal> to create the record for <literal>c</literal>"
+msgstr "一条 <literal>INSERT</literal> 语句，为 <literal>c</literal> 创建一条记录"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"an <literal>UPDATE</literal> to create the link from <literal>p</literal> to "
-"<literal>c</literal>"
-msgstr ""
-"一条 <literal>UPDATE</literal> 语句，创建从 <literal>p</literal> 到 "
-"<literal>c</literal> 的连接"
+msgid "an <literal>UPDATE</literal> to create the link from <literal>p</literal> to <literal>c</literal>"
+msgstr "一条 <literal>UPDATE</literal> 语句，创建从 <literal>p</literal> 到 <literal>c</literal> 的连接"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This is not only inefficient, but also violates any <literal>NOT NULL</"
-"literal> constraint on the <literal>parent_id</literal> column. You can fix "
-"the nullability constraint violation by specifying <literal>not-null=\"true"
-"\"</literal> in the collection mapping:"
-msgstr ""
-"è¿™æ ·åšä¸ä»…æ•ˆçŽ‡ä½Žï¼Œè€Œä¸”è¿åäº† <literal>parent_id</literal> 列 "
-"<literal>parent_id</literal> éžç©ºçš„é™åˆ¶ã€‚æˆ‘ä»¬å¯ä»¥é€šè¿‡åœ¨é›†åˆç±»æ˜ å°„ä¸ŠæŒ‡å®š "
-"<literal>not-null=\"true\"</literal> 来解决违反非空约束的问题："
+msgid "This is not only inefficient, but also violates any <literal>NOT NULL</literal> constraint on the <literal>parent_id</literal> column. You can fix the nullability constraint violation by specifying <literal>not-null=\"true\"</literal> in the collection mapping:"
+msgstr "è¿™æ ·åšä¸ä»…æ•ˆçŽ‡ä½Žï¼Œè€Œä¸”è¿åäº† <literal>parent_id</literal> 列 <literal>parent_id</literal> éžç©ºçš„é™åˆ¶ã€‚æˆ‘ä»¬å¯ä»¥é€šè¿‡åœ¨é›†åˆç±»æ˜ å°„ä¸ŠæŒ‡å®š <literal>not-null=\"true\"</literal> 来解决违反非空约束的问题："
 
 #. Tag: para
 #, no-c-format
@@ -169,35 +96,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The underlying cause of this behavior is that the link (the foreign key "
-"<literal>parent_id</literal>) from <literal>p</literal> to <literal>c</"
-"literal> is not considered part of the state of the <literal>Child</literal> "
-"object and is therefore not created in the <literal>INSERT</literal>. The "
-"solution is to make the link part of the <literal>Child</literal> mapping."
-msgstr ""
-"è¿™ç§çŽ°è±¡çš„æ ¹æœ¬åŽŸå› æ˜¯ä»Ž <literal>p</literal> 到 <literal>c</literal> 的连接"
-"（外键 parent_id）没有被当作 <literal>Child</literal> å¯¹è±¡çŠ¶æ€çš„ä¸€éƒ¨åˆ†ï¼Œå› è€Œ"
-"没有在 <literal>INSERT</literal> è¯­å¥ä¸­è¢«åˆ›å»ºã€‚å› æ­¤è§£å†³çš„åŠžæ³•å°±æ˜¯æŠŠè¿™ä¸ªè¿žæŽ¥æ·»"
-"åŠ åˆ° <literal>Child</literal> çš„æ˜ å°„ä¸­ã€‚"
+msgid "The underlying cause of this behavior is that the link (the foreign key <literal>parent_id</literal>) from <literal>p</literal> to <literal>c</literal> is not considered part of the state of the <literal>Child</literal> object and is therefore not created in the <literal>INSERT</literal>. The solution is to make the link part of the <literal>Child</literal> mapping."
+msgstr "è¿™ç§çŽ°è±¡çš„æ ¹æœ¬åŽŸå› æ˜¯ä»Ž <literal>p</literal> 到 <literal>c</literal> 的连接（外键 parent_id）没有被当作 <literal>Child</literal> å¯¹è±¡çŠ¶æ€çš„ä¸€éƒ¨åˆ†ï¼Œå› è€Œæ²¡æœ‰åœ¨ <literal>INSERT</literal> è¯­å¥ä¸­è¢«åˆ›å»ºã€‚å› æ­¤è§£å†³çš„åŠžæ³•å°±æ˜¯æŠŠè¿™ä¸ªè¿žæŽ¥æ·»åŠ åˆ° <literal>Child</literal> çš„æ˜ å°„ä¸­ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You also need to add the <literal>parent</literal> property to the "
-"<literal>Child</literal> class."
-msgstr ""
-"ä½ è¿˜éœ€è¦ä¸ºç±» <literal>Child</literal> æ·»åŠ  <literal>parent</literal> 属性。"
+msgid "You also need to add the <literal>parent</literal> property to the <literal>Child</literal> class."
+msgstr "ä½ è¿˜éœ€è¦ä¸ºç±» <literal>Child</literal> æ·»åŠ  <literal>parent</literal> 属性。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Now that the <literal>Child</literal> entity is managing the state of the "
-"link, we tell the collection not to update the link. We use the "
-"<literal>inverse</literal> attribute to do this:"
-msgstr ""
-"现在实体 <literal>Child</literal> 在管理连接的状态，为了使 collection 不更新"
-"连接，我们使用 <literal>inverse</literal> 属性："
+msgid "Now that the <literal>Child</literal> entity is managing the state of the link, we tell the collection not to update the link. We use the <literal>inverse</literal> attribute to do this:"
+msgstr "现在实体 <literal>Child</literal> 在管理连接的状态，为了使 collection 不更新连接，我们使用 <literal>inverse</literal> 属性："
 
 #. Tag: para
 #, no-c-format
@@ -211,12 +121,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You could also create an <literal>addChild()</literal> method of "
-"<literal>Parent</literal>."
-msgstr ""
-"为了让事情变得井井有条，可以为 <literal>Parent</literal> åŠ ä¸€ä¸ª "
-"<literal>addChild()</literal> 方法。"
+msgid "You could also create an <literal>addChild()</literal> method of <literal>Parent</literal>."
+msgstr "为了让事情变得井井有条，可以为 <literal>Parent</literal> åŠ ä¸€ä¸ª <literal>addChild()</literal> 方法。"
 
 #. Tag: para
 #, no-c-format
@@ -230,12 +136,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can address the frustrations of the explicit call to <literal>save()</"
-"literal> by using cascades."
-msgstr ""
-"需要显式调用 <literal>save()</literal> 仍然很麻烦，我们可以用级联来解决这个问"
-"题。 "
+msgid "You can address the frustrations of the explicit call to <literal>save()</literal> by using cascades."
+msgstr "需要显式调用 <literal>save()</literal> 仍然很麻烦，我们可以用级联来解决这个问题。 "
 
 #. Tag: para
 #, no-c-format
@@ -244,13 +146,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Similarly, we do not need to iterate over the children when saving or "
-"deleting a <literal>Parent</literal>. The following removes <literal>p</"
-"literal> and all its children from the database."
-msgstr ""
-"åŒæ ·çš„ï¼Œä¿å­˜æˆ–åˆ é™¤ <literal>Parent</literal> 对象的时候并不需要遍历其子对象。"
-"ä¸‹é¢çš„ä»£ç ä¼šåˆ é™¤å¯¹è±¡ <literal>p</literal> 及其所有子对象对应的数据库记录。 "
+msgid "Similarly, we do not need to iterate over the children when saving or deleting a <literal>Parent</literal>. The following removes <literal>p</literal> and all its children from the database."
+msgstr "åŒæ ·çš„ï¼Œä¿å­˜æˆ–åˆ é™¤ <literal>Parent</literal> å¯¹è±¡çš„æ—¶å€™å¹¶ä¸éœ€è¦éåŽ†å…¶å­å¯¹è±¡ã€‚ä¸‹é¢çš„ä»£ç ä¼šåˆ é™¤å¯¹è±¡ <literal>p</literal> 及其所有子对象对应的数据库记录。 "
 
 #. Tag: para
 #, no-c-format
@@ -259,41 +156,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"will not remove <literal>c</literal> from the database. In this case, it "
-"will only remove the link to <literal>p</literal> and cause a <literal>NOT "
-"NULL</literal> constraint violation. You need to explicitly <literal>delete()"
-"</literal> the <literal>Child</literal>."
-msgstr ""
-"ä¸ä¼šä»Žæ•°æ®åº“åˆ é™¤<literal>c</literal>ï¼›å®ƒåªä¼šåˆ é™¤ä¸Ž <literal>p</literal> 之间"
-"的连接（并且会导致违反 <literal>NOT NULL</literal> çº¦æŸï¼Œåœ¨è¿™ä¸ªä¾‹å­ä¸­ï¼‰ã€‚ä½ éœ€"
-"要显式调用 <literal>delete()</literal> æ¥åˆ é™¤ <literal>Child</literal>。 "
+msgid "will not remove <literal>c</literal> from the database. In this case, it will only remove the link to <literal>p</literal> and cause a <literal>NOT NULL</literal> constraint violation. You need to explicitly <literal>delete()</literal> the <literal>Child</literal>."
+msgstr "ä¸ä¼šä»Žæ•°æ®åº“åˆ é™¤<literal>c</literal>ï¼›å®ƒåªä¼šåˆ é™¤ä¸Ž <literal>p</literal> 之间的连接（并且会导致违反 <literal>NOT NULL</literal> çº¦æŸï¼Œåœ¨è¿™ä¸ªä¾‹å­ä¸­ï¼‰ã€‚ä½ éœ€è¦æ˜¾å¼è°ƒç”¨ <literal>delete()</literal> æ¥åˆ é™¤ <literal>Child</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In our case, a <literal>Child</literal> cannot exist without its parent. So "
-"if we remove a <literal>Child</literal> from the collection, we do want it "
-"to be deleted. To do this, we must use <literal>cascade=\"all-delete-orphan"
-"\"</literal>."
-msgstr ""
-"在我们的例子中，如果没有父对象，子对象就不应该存在，如果将子对象从 "
-"collection ä¸­ç§»é™¤ï¼Œå®žé™…ä¸Šæˆ‘ä»¬æ˜¯æƒ³åˆ é™¤å®ƒã€‚è¦å®žçŽ°è¿™ç§è¦æ±‚ï¼Œå°±å¿…é¡»ä½¿ç”¨ "
-"<literal>cascade=\"all-delete-orphan\"</literal>。 "
+msgid "In our case, a <literal>Child</literal> cannot exist without its parent. So if we remove a <literal>Child</literal> from the collection, we do want it to be deleted. To do this, we must use <literal>cascade=\"all-delete-orphan\"</literal>."
+msgstr "在我们的例子中，如果没有父对象，子对象就不应该存在，如果将子对象从 collection ä¸­ç§»é™¤ï¼Œå®žé™…ä¸Šæˆ‘ä»¬æ˜¯æƒ³åˆ é™¤å®ƒã€‚è¦å®žçŽ°è¿™ç§è¦æ±‚ï¼Œå°±å¿…é¡»ä½¿ç”¨ <literal>cascade=\"all-delete-orphan\"</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Even though the collection mapping specifies <literal>inverse=\"true\"</"
-"literal>, cascades are still processed by iterating the collection elements. "
-"If you need an object be saved, deleted or updated by cascade, you must add "
-"it to the collection. It is not enough to simply call <literal>setParent()</"
-"literal>."
-msgstr ""
-"注意：即使在 collection ä¸€æ–¹çš„æ˜ å°„ä¸­æŒ‡å®š <literal>inverse=\"true\"</"
-"literal>，级联仍然是通过遍历 collection ä¸­çš„å…ƒç´ æ¥å¤„ç†çš„ã€‚å¦‚æžœä½ æƒ³è¦é€šè¿‡çº§è”"
-"è¿›è¡Œå­å¯¹è±¡çš„æ’å…¥ã€åˆ é™¤ã€æ›´æ–°æ“ä½œï¼Œå°±å¿…é¡»æŠŠå®ƒåŠ åˆ° collection 中，只调用 "
-"<literal>setParent()</literal> 是不够的。 "
+msgid "Even though the collection mapping specifies <literal>inverse=\"true\"</literal>, cascades are still processed by iterating the collection elements. If you need an object be saved, deleted or updated by cascade, you must add it to the collection. It is not enough to simply call <literal>setParent()</literal>."
+msgstr "注意：即使在 collection ä¸€æ–¹çš„æ˜ å°„ä¸­æŒ‡å®š <literal>inverse=\"true\"</literal>，级联仍然是通过遍历 collection ä¸­çš„å…ƒç´ æ¥å¤„ç†çš„ã€‚å¦‚æžœä½ æƒ³è¦é€šè¿‡çº§è”è¿›è¡Œå­å¯¹è±¡çš„æ’å…¥ã€åˆ é™¤ã€æ›´æ–°æ“ä½œï¼Œå°±å¿…é¡»æŠŠå®ƒåŠ åˆ° collection 中，只调用 <literal>setParent()</literal> 是不够的。 "
 
 #. Tag: title
 #, no-c-format
@@ -301,57 +175,19 @@
 msgstr "级联与未保存值（<literal>unsaved-value</literal>）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</"
-"literal>, made some changes in a UI action and wanted to persist these "
-"changes in a new session by calling <literal>update()</literal>. The "
-"<literal>Parent</literal> will contain a collection of children and, since "
-"the cascading update is enabled, Hibernate needs to know which children are "
-"newly instantiated and which represent existing rows in the database. We "
-"will also assume that both <literal>Parent</literal> and <literal>Child</"
-"literal> have generated identifier properties of type <literal>Long</"
-"literal>. Hibernate will use the identifier and version/timestamp property "
-"value to determine which of the children are new. (See <xref linkend="
-"\"objectstate-saveorupdate\" />.) <emphasis>In Hibernate3, it is no longer "
-"necessary to specify an <literal>unsaved-value</literal> explicitly.</"
-"emphasis>"
-msgstr ""
-"假设我们从 <literal>Session</literal> 中装入了一个 <literal>Parent</literal> "
-"对象，用户界面对其进行了修改，然后希望在一个新的 Session 里面调用 "
-"<literal>update()</literal> 来保存这些修改。对象 <literal>Parent</literal> 包"
-"含了子对象的集合，由于打开了级联更新，Hibernate 需要知道哪些 Child 对象是新实"
-"例化的，哪些代表数据库中已经存在的记录。我们假设 <literal>Parent</literal> "
-"å’Œ <literal>Child</literal> å¯¹è±¡çš„æ ‡è¯†å±žæ€§éƒ½æ˜¯è‡ªåŠ¨ç”Ÿæˆçš„ï¼Œç±»åž‹ä¸º "
-"<literal>java.lang.Long</literal>。Hibernate ä¼šä½¿ç”¨æ ‡è¯†å±žæ€§çš„å€¼ï¼Œå’Œ version "
-"或 timestamp 属性，来判断哪些子对象是新的。（参见 <xref linkend="
-"\"objectstate-saveorupdate\"/>）<emphasis>在 Hibernate3 中,显式指定 "
-"<literal>unsaved-value</literal> 不再是必须的了。</emphasis>"
+#, no-c-format
+msgid "Suppose we loaded up a <literal>Parent</literal> in one <literal>Session</literal>, made some changes in a UI action and wanted to persist these changes in a new session by calling <literal>update()</literal>. The <literal>Parent</literal> will contain a collection of children and, since the cascading update is enabled, Hibernate needs to know which children are newly instantiated and which represent existing rows in the database. We will also assume that both <literal>Parent</literal> and <literal>Child</literal> have generated identifier properties of type <literal>Long</literal>. Hibernate will use the identifier and version/timestamp property value to determine which of the children are new. (See <xref linkend=\"objectstate-saveorupdate\" />.) <emphasis>In Hibernate3, it is no longer necessary to specify an <literal>unsaved-value</literal> explicitly.</emphasis>"
+msgstr "假设我们从 <literal>Session</literal> 中装入了一个 <literal>Parent</literal> 对象，用户界面对其进行了修改，然后希望在一个新的 Session 里面调用 <literal>update()</literal> 来保存这些修改。对象 <literal>Parent</literal> 包含了子对象的集合，由于打开了级联更新，Hibernate 需要知道哪些 Child 对象是新实例化的，哪些代表数据库中已经存在的记录。我们假设 <literal>Parent</literal> å’Œ <literal>Child</literal> å¯¹è±¡çš„æ ‡è¯†å±žæ€§éƒ½æ˜¯è‡ªåŠ¨ç”Ÿæˆçš„ï¼Œç±»åž‹ä¸º <literal>java.lang.Long</literal>。Hibernate ä¼šä½¿ç”¨æ ‡è¯†å±žæ€§çš„å€¼ï¼Œå’Œ version 或 timestamp 属性，来判断哪些子对象是新的。（参见 <xref linkend=\"objectstate-saveorupdate\"/>）<emphasis>在 Hibernate3 中,显式指定 <literal>unsaved-value</literal> 不再是必须的了。</emphasis> "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The following code will update <literal>parent</literal> and <literal>child</"
-"literal> and insert <literal>newChild</literal>:"
-msgstr ""
-"ä¸‹é¢çš„ä»£ç ä¼šæ›´æ–° <literal>parent</literal> å’Œ <literal>child</literal> 对象，"
-"并且插入 <literal>newChild</literal> 对象。 "
+msgid "The following code will update <literal>parent</literal> and <literal>child</literal> and insert <literal>newChild</literal>:"
+msgstr "ä¸‹é¢çš„ä»£ç ä¼šæ›´æ–° <literal>parent</literal> å’Œ <literal>child</literal> 对象，并且插入 <literal>newChild</literal> 对象。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This may be suitable for the case of a generated identifier, but what about "
-"assigned identifiers and composite identifiers? This is more difficult, "
-"since Hibernate cannot use the identifier property to distinguish between a "
-"newly instantiated object, with an identifier assigned by the user, and an "
-"object loaded in a previous session. In this case, Hibernate will either use "
-"the timestamp or version property, or will actually query the second-level "
-"cache or, worst case, the database, to see if the row exists."
-msgstr ""
-"è¿™å¯¹äºŽè‡ªåŠ¨ç”Ÿæˆæ ‡è¯†çš„æƒ…å†µæ˜¯éžå¸¸å¥½çš„ï¼Œä½†æ˜¯è‡ªåˆ†é…çš„æ ‡è¯†å’Œå¤åˆæ ‡è¯†æ€Žä¹ˆåŠžå‘¢ï¼Ÿè¿™æ˜¯"
-"æœ‰ç‚¹éº»çƒ¦ï¼Œå› ä¸º Hibernate æ²¡æœ‰åŠžæ³•åŒºåˆ†æ–°å®žä¾‹åŒ–çš„å¯¹è±¡ï¼ˆæ ‡è¯†è¢«ç”¨æˆ·æŒ‡å®šäº†ï¼‰å’Œå‰ä¸€"
-"个 Session 装入的对象。在这种情况下，Hibernate 会使用 timestamp 或 version 属"
-"性，或者查询第二级缓存，或者最坏的情况，查询数据库，来确认是否此行存在。 "
+msgid "This may be suitable for the case of a generated identifier, but what about assigned identifiers and composite identifiers? This is more difficult, since Hibernate cannot use the identifier property to distinguish between a newly instantiated object, with an identifier assigned by the user, and an object loaded in a previous session. In this case, Hibernate will either use the timestamp or version property, or will actually query the second-level cache or, worst case, the database, to see if the row exists."
+msgstr "è¿™å¯¹äºŽè‡ªåŠ¨ç”Ÿæˆæ ‡è¯†çš„æƒ…å†µæ˜¯éžå¸¸å¥½çš„ï¼Œä½†æ˜¯è‡ªåˆ†é…çš„æ ‡è¯†å’Œå¤åˆæ ‡è¯†æ€Žä¹ˆåŠžå‘¢ï¼Ÿè¿™æ˜¯æœ‰ç‚¹éº»çƒ¦ï¼Œå› ä¸º Hibernate æ²¡æœ‰åŠžæ³•åŒºåˆ†æ–°å®žä¾‹åŒ–çš„å¯¹è±¡ï¼ˆæ ‡è¯†è¢«ç”¨æˆ·æŒ‡å®šäº†ï¼‰å’Œå‰ä¸€ä¸ª Session 装入的对象。在这种情况下，Hibernate 会使用 timestamp 或 version 属性，或者查询第二级缓存，或者最坏的情况，查询数据库，来确认是否此行存在。 "
 
 #. Tag: title
 #, no-c-format
@@ -360,28 +196,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The sections we have just covered can be a bit confusing. However, in "
-"practice, it all works out nicely. Most Hibernate applications use the "
-"parent/child pattern in many places."
-msgstr ""
-"这里有不少东西需要融会贯通，可能会让新手感到迷惑。但是在实践中它们都工作地非"
-"常好。大部分 Hibernate 应用程序都会经常用到父子对象模式。 "
+msgid "The sections we have just covered can be a bit confusing. However, in practice, it all works out nicely. Most Hibernate applications use the parent/child pattern in many places."
+msgstr "这里有不少东西需要融会贯通，可能会让新手感到迷惑。但是在实践中它们都工作地非常好。大部分 Hibernate 应用程序都会经常用到父子对象模式。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"We mentioned an alternative in the first paragraph. None of the above issues "
-"exist in the case of <literal>&lt;composite-element&gt;</literal> mappings, "
-"which have exactly the semantics of a parent/child relationship. "
-"Unfortunately, there are two big limitations with composite element classes: "
-"composite elements cannot own collections and they should not be the child "
-"of any entity other than the unique parent."
-msgstr ""
-"在第一段中我们曾经提到另一个方案。上面的这些问题都不会出现在 <literal>&lt;"
-"composite-element&gt;</literal> æ˜ å°„ä¸­ï¼Œå®ƒå‡†ç¡®åœ°è¡¨è¾¾äº†çˆ¶å­å…³ç³»çš„è¯­ä¹‰ã€‚å¾ˆä¸å¹¸"
-"å¤åˆå…ƒç´ è¿˜æœ‰ä¸¤ä¸ªé‡å¤§é™åˆ¶ï¼šå¤åˆå…ƒç´ ä¸èƒ½æ‹¥æœ‰ collections，并且，除了用于惟一的"
-"父对象外，它们不能再作为其它任何实体的子对象。 "
+msgid "We mentioned an alternative in the first paragraph. None of the above issues exist in the case of <literal>&lt;composite-element&gt;</literal> mappings, which have exactly the semantics of a parent/child relationship. Unfortunately, there are two big limitations with composite element classes: composite elements cannot own collections and they should not be the child of any entity other than the unique parent."
+msgstr "在第一段中我们曾经提到另一个方案。上面的这些问题都不会出现在 <literal>&lt;composite-element&gt;</literal> æ˜ å°„ä¸­ï¼Œå®ƒå‡†ç¡®åœ°è¡¨è¾¾äº†çˆ¶å­å…³ç³»çš„è¯­ä¹‰ã€‚å¾ˆä¸å¹¸å¤åˆå…ƒç´ è¿˜æœ‰ä¸¤ä¸ªé‡å¤§é™åˆ¶ï¼šå¤åˆå…ƒç´ ä¸èƒ½æ‹¥æœ‰ collections，并且，除了用于惟一的父对象外，它们不能再作为其它任何实体的子对象。 "
 
 #~ msgid ""
 #~ "<![CDATA[<set name=\"children\">\n"
@@ -393,7 +214,6 @@
 #~ "    <key column=\"parent_id\"/>\n"
 #~ "    <one-to-many class=\"Child\"/>\n"
 #~ "</set>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = .....;\n"
 #~ "Child c = new Child();\n"
@@ -406,7 +226,6 @@
 #~ "p.getChildren().add(c);\n"
 #~ "session.save(c);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<set name=\"children\">\n"
 #~ "    <key column=\"parent_id\" not-null=\"true\"/>\n"
@@ -417,14 +236,12 @@
 #~ "    <key column=\"parent_id\" not-null=\"true\"/>\n"
 #~ "    <one-to-many class=\"Child\"/>\n"
 #~ "</set>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true"
 #~ "\"/>]]>"
 #~ msgstr ""
 #~ "<![CDATA[<many-to-one name=\"parent\" column=\"parent_id\" not-null=\"true"
 #~ "\"/>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<set name=\"children\" inverse=\"true\">\n"
 #~ "    <key column=\"parent_id\"/>\n"
@@ -435,7 +252,6 @@
 #~ "    <key column=\"parent_id\"/>\n"
 #~ "    <one-to-many class=\"Child\"/>\n"
 #~ "</set>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "Child c = new Child();\n"
@@ -450,7 +266,6 @@
 #~ "p.getChildren().add(c);\n"
 #~ "session.save(c);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[public void addChild(Child c) {\n"
 #~ "    c.setParent(this);\n"
@@ -461,7 +276,6 @@
 #~ "    c.setParent(this);\n"
 #~ "    children.add(c);\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "Child c = new Child();\n"
@@ -474,7 +288,6 @@
 #~ "p.addChild(c);\n"
 #~ "session.save(c);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all\">\n"
 #~ "    <key column=\"parent_id\"/>\n"
@@ -485,7 +298,6 @@
 #~ "    <key column=\"parent_id\"/>\n"
 #~ "    <one-to-many class=\"Child\"/>\n"
 #~ "</set>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "Child c = new Child();\n"
@@ -496,7 +308,6 @@
 #~ "Child c = new Child();\n"
 #~ "p.addChild(c);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "session.delete(p);\n"
@@ -505,7 +316,6 @@
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "session.delete(p);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "Child c = (Child) p.getChildren().iterator().next();\n"
@@ -518,7 +328,6 @@
 #~ "p.getChildren().remove(c);\n"
 #~ "c.setParent(null);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[Parent p = (Parent) session.load(Parent.class, pid);\n"
 #~ "Child c = (Child) p.getChildren().iterator().next();\n"
@@ -531,7 +340,6 @@
 #~ "p.getChildren().remove(c);\n"
 #~ "session.delete(c);\n"
 #~ "session.flush();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[<set name=\"children\" inverse=\"true\" cascade=\"all-delete-"
 #~ "orphan\">\n"
@@ -544,7 +352,6 @@
 #~ "    <key column=\"parent_id\"/>\n"
 #~ "    <one-to-many class=\"Child\"/>\n"
 #~ "</set>]]>"
-
 #~ msgid ""
 #~ "<![CDATA[//parent and child were both loaded in a previous session\n"
 #~ "parent.addChild(child);\n"
@@ -559,3 +366,4 @@
 #~ "parent.addChild(newChild);\n"
 #~ "session.update(parent);\n"
 #~ "session.flush();]]>"
+

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-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/portability.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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: 2009-12-07 20:00+1000\n"
+"PO-Revision-Date: 2009-12-11 10:48+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -37,7 +37,7 @@
 #. 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."
-msgstr ""
+msgstr "Hibernate 的移植性的首要问题是方言（dialect），也就是 <classname>org.hibernate.dialect.Dialect</classname> 合约的具体实例。方言封装了 Hibernate 和特定数据库通讯以完成某些任务如获取序列值或构建 SELECT 查询等的所有差异。Hibernate æ†ç»‘äº†ç”¨äºŽè®¸å¤šæœ€å¸¸ç”¨çš„æ•°æ®åº“çš„æ–¹è¨€ã€‚å¦‚æžœä½ å‘çŽ°è‡ªå·±ä½¿ç”¨çš„æ•°æ®åº“ä¸åœ¨å…¶ä¸­ï¼Œç¼–å†™è‡ªå®šä¹‰çš„æ–¹è¨€ä¹Ÿä¸æ˜¯å¾ˆå›°éš¾çš„äº‹æƒ…ã€‚"
 
 #. Tag: title
 #, no-c-format
@@ -52,17 +52,17 @@
 #. 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."
-msgstr ""
+msgstr "从版本 3.2 开始，Hibernate 引入了方言的自动检测，它基于从该数据库的 <interfacename>java.sql.Connection</interfacename> 上获得的 <interfacename>java.sql.DatabaseMetaData</interfacename>。这是一个更好的方案，但它局限于 Hibernate å·²çŸ¥çš„æ•°æ®åº“ä¸”æ— æ³•è¿›è¡Œé…ç½®å’Œè¦†ç›–ã€‚"
 
 #. 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."
-msgstr ""
+msgstr "从版本 3.2 开始，Hibernate æœ‰äº†æ›´ä¸ºå¼ºå¤§çš„è‡ªåŠ¨å†³å®šåº”è¯¥ä½¿ç”¨å“ªä¸ªæ–¹è¨€çš„æ–¹æ³•ï¼Œè¿™æ ¹æ®ä¸€ç³»åˆ—å®žçŽ° <interfacename>org.hibernate.dialect.resolver.DialectResolver</interfacename> 接口的代理，它们只定义一个方法：<programlisting>public Dialect resolveDialect(DatabaseMetaData metaData) throws JDBCConnectionException</programlisting>。这里的基本合约是如果解析者（resolver）“理解”给点数据库的元数据并返回对应的方言；否则返回 null 并使用下一个解析者。这个签名也指定可能抛出的异常 <exceptionname>org.hibernate.exception.JDBCConnectionException</exceptionname>。这里的 JDBCConnectionException 被认为是“非瞬时的”（也就是不可恢复的）连接问题且指示立即终止解析。所有其他的异常都导致警告发出并使用下一个解析者。"
 
 #. 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>)."
-msgstr ""
+msgstr "è¿™äº›è§£æžè€…æœ€æ£’çš„åŠŸèƒ½æ˜¯ç”¨æˆ·ä¹Ÿå¯ä»¥æ³¨å†Œè‡ªå®šä¹‰çš„è§£æžè€…ï¼Œå®ƒä»¬å°†åœ¨å†…ç½®çš„è§£æžè€…ä¹‹å‰è¢«è°ƒç”¨ã€‚åœ¨è®¸å¤šæƒ…å†µä¸‹è¿™å¯èƒ½å¾ˆæœ‰ç”¨ï¼šå®ƒå¯ä»¥è½»æ˜“åœ°é›†æˆå†…ç½®æ–¹è¨€ä¹‹å¤–çš„æ–¹è¨€çš„è‡ªåŠ¨æ£€æµ‹ï¼›å®ƒè®©ä½ å¯ä»¥ä½¿ç”¨è‡ªå®šä¹‰çš„æ–¹è¨€ç­‰ã€‚è¦æ³¨å†Œä¸€ä¸ªæˆ–å¤šä¸ªè§£æžè€…ï¼Œåªè¦ç”¨ 'hibernate.dialect_resolvers' é…ç½®è®¾ç½®æŒ‡å®šå®ƒä»¬ï¼ˆç”±é€—å·ã€åˆ¶è¡¨ç¬¦æˆ–ç©ºæ ¼éš”å¼€ï¼‰å°±å¯ä»¥äº†ï¼ˆè¯·å‚è€ƒ <classname>org.hibernate.cfg.Environment</classname> 上的 <constant>DIALECT_RESOLVERS</constant>）。"
 
 #. Tag: title
 #, no-c-format
@@ -72,7 +72,7 @@
 #. 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 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 ""
+msgstr "å½“è€ƒè™‘æ•°æ®åº“çš„ç§»æ¤æ€§æ—¶ï¼Œå¦å¤–ä¸€ä¸ªé‡è¦çš„è€ƒé‡æ˜¯é€‰æ‹©æ ‡è¯†ç¬¦ç”Ÿæˆç­–ç•¥ã€‚Hibernate 原先提供的 <emphasis>native</emphasis> ç”Ÿæˆå™¨çš„ç›®çš„æ˜¯æ ¹æ®åº•å±‚æ•°æ®åº“çš„èƒ½åŠ›åœ¨ <emphasis>sequence</emphasis>、<emphasis>identity</emphasis> 或 <emphasis>table</emphasis> 策略间进行选择。然而，这个方法一个潜在的问题是有些数据库支持<emphasis>æ ‡è¯†ç¬¦ï¼ˆidentity）</emphasis>生成而有些则不支持。<emphasis>æ ‡è¯†ç¬¦ï¼ˆidentity）</emphasis> ç”Ÿæˆä¾èµ–äºŽç®¡ç†æ ‡è¯†ç¬¦å€¼çš„ IDENTITY（或 auto-increment）字段的 SQL 定义。它也成为 post-insert ç”Ÿæˆç­–ç•¥ï¼Œå› ä¸º insert å¿…é¡»åœ¨çŸ¥é“æ ‡è¯†ç¬¦å€¼åŽæ‰èƒ½å®žé™…å‘ç”Ÿã€‚å› ä¸º Hibernate ä¾èµ–äºŽè¿™ä¸ªæ ‡è¯†ç¬¦å€¼æ¥å”¯ä¸€åœ°å¼•ç”¨æŒä¹…æ€§ä¸Šä¸‹æ–‡é‡Œçš„å®žä½“ï¼Œå½“ç”¨æˆ·è¯·æ±‚å’Œä¼šè¯ç›¸å…³è”çš„å®žä½“æ—¶ï¼Œå®ƒå¿…é¡»ç«‹å³æ‰§è¡Œ insert  语句而不管当前的事务性语义。底层的问题是应用程序的语义在这些情况下自è!
 º«ä¹Ÿä¼šå‘生改变。"
 
 #. Tag: para
 #, no-c-format
@@ -112,20 +112,20 @@
 #. 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."
-msgstr ""
+msgstr "这是 Hibernate 的一个新的领域，暂时还不如 Hibernate 总体那么成熟。"
 
 #. 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."
-msgstr ""
+msgstr "用户可以以多种方式引用 SQL 函数。然而，不是所有的数据库都支持相同的函数集。Hibernate æä¾›äº†ä¸€ç§æ˜ å°„<emphasis>逻辑</emphasis>函数名到代理的方法，这个代理知道如何解析特定的函数，甚至可能使用完全不同的物理函数调用。"
 
 #. 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."
-msgstr ""
+msgstr "从技术上来讲，这个函数注册是通过 <classname>org.hibernate.dialect.function.SQLFunctionRegistry</classname> ç±»è¿›è¡Œå¤„ç†çš„ï¼Œå®ƒçš„ç›®çš„æ˜¯å…è®¸ç”¨æˆ·æä¾›è‡ªå®šä¹‰çš„å‡½æ•°å®šä¹‰è€Œæ— éœ€æä¾›è‡ªå®šä¹‰çš„æ–¹è¨€ã€‚è¿™ç§ç‰¹æ®Šçš„è¡Œä¸ºç›®å‰è¿˜æœªå…¨éƒ¨å¼€å‘å®Œæ¯•ã€‚"
 
 #. 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."
-msgstr ""
+msgstr "其中一些功能已经实现，如用户可以在程序里用 <classname>org.hibernate.cfg.Configuration</classname> 注册函数且这些函数可被 HQL 识别。"
 

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/preface.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/preface.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/preface.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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-11 09:54+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -21,108 +21,43 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Working with object-oriented software and a relational database can be "
-"cumbersome and time consuming in today's enterprise environments. Hibernate "
-"is an object/relational mapping tool for Java environments. The term object/"
-"relational mapping (ORM) refers to the technique of mapping a data "
-"representation from an object model to a relational data model with a SQL-"
-"based schema."
-msgstr ""
-"在今日的企业环境中，把面向对象的软件和关系型数据库一起使用可能是相当麻烦和浪"
-"费时间的。Hibernate 是一个面向 Java 环境的对象/å…³ç³»åž‹æ•°æ®åº“æ˜ å°„å·¥å…·ã€‚å¯¹è±¡/å…³"
-"ç³»åž‹æ•°æ®åº“æ˜ å°„ï¼ˆobject/relational mapping，ORM）这个术语表示一种技术，用来把"
-"å¯¹è±¡æ¨¡åž‹è¡¨ç¤ºçš„å¯¹è±¡æ˜ å°„åˆ°åŸºäºŽ SQL 的关系模型数据结构中去。"
+msgid "Working with object-oriented software and a relational database can be cumbersome and time consuming in today's enterprise environments. Hibernate is an object/relational mapping tool for Java environments. The term object/relational mapping (ORM) refers to the technique of mapping a data representation from an object model to a relational data model with a SQL-based schema."
+msgstr "在今日的企业环境中，把面向对象的软件和关系型数据库一起使用可能是相当麻烦和浪费时间的。Hibernate 是一个面向 Java 环境的对象/å…³ç³»åž‹æ•°æ®åº“æ˜ å°„å·¥å…·ã€‚å¯¹è±¡/å…³ç³»åž‹æ•°æ®åº“æ˜ å°„ï¼ˆobject/relational mapping，ORMï¼‰è¿™ä¸ªæœ¯è¯­è¡¨ç¤ºä¸€ç§æŠ€æœ¯ï¼Œç”¨æ¥æŠŠå¯¹è±¡æ¨¡åž‹è¡¨ç¤ºçš„å¯¹è±¡æ˜ å°„åˆ°åŸºäºŽ SQL 的关系模型数据结构中去。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate not only takes care of the mapping from Java classes to database "
-"tables (and from Java data types to SQL data types), but also provides data "
-"query and retrieval facilities. It can also significantly reduce development "
-"time otherwise spent with manual data handling in SQL and JDBC."
-msgstr ""
-"Hibernate 不仅管理 Java ç±»åˆ°æ•°æ®åº“è¡¨çš„æ˜ å°„ï¼ˆåŒ…æ‹¬ Java 数据类型到 SQL 数据类型"
-"çš„æ˜ å°„ï¼‰ï¼Œè¿˜æä¾›æ•°æ®æŸ¥è¯¢å’ŒèŽ·å–æ•°æ®çš„æ–¹æ³•ï¼Œå¯ä»¥å¤§å¹…åº¦å‡å°‘å¼€å‘æ—¶å¯¹äººå·¥ä½¿ç”¨ SQL "
-"和 JDBC 处理数据的时间。"
+#, no-c-format
+msgid "Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities. It can also significantly reduce development time otherwise spent with manual data handling in SQL and JDBC."
+msgstr "Hibernate 不仅管理 Java ç±»åˆ°æ•°æ®åº“è¡¨çš„æ˜ å°„ï¼ˆåŒ…æ‹¬ Java 数据类型到 SQL æ•°æ®ç±»åž‹çš„æ˜ å°„ï¼‰ï¼Œè¿˜æä¾›æ•°æ®æŸ¥è¯¢å’ŒèŽ·å–æ•°æ®çš„æ–¹æ³•ï¼Œå¯ä»¥å¤§å¹…åº¦å‡å°‘å¼€å‘æ—¶å¯¹äººå·¥ä½¿ç”¨ SQL å’Œ JDBC 处理数据的时间。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate's goal is to relieve the developer from 95 percent of common data "
-"persistence related programming tasks. Hibernate may not be the best "
-"solution for data-centric applications that only use stored-procedures to "
-"implement the business logic in the database, it is most useful with object-"
-"oriented domain models and business logic in the Java-based middle-tier. "
-"However, Hibernate can certainly help you to remove or encapsulate vendor-"
-"specific SQL code and will help with the common task of result set "
-"translation from a tabular representation to a graph of objects."
-msgstr ""
-"Hibernate çš„ç›®æ ‡æ˜¯å¯¹äºŽå¼€å‘è€…é€šå¸¸çš„æ•°æ®æŒä¹…åŒ–ç›¸å…³çš„ç¼–ç¨‹ä»»åŠ¡ï¼Œè§£æ”¾å…¶ä¸­çš„ 95%。"
-"对于以数据为中心的程序来说，它们往往只在数据库中使用存储过程来实现商业逻辑，"
-"Hibernate 可能不是最好的解决方案；对于那些在基于 Java 的中间层应用中，它们实"
-"现面向对象的业务模型和商业逻辑的应用，Hibernate æ˜¯æœ€æœ‰ç”¨çš„ã€‚ä¸ç®¡æ€Žæ ·ï¼Œ"
-"Hibernate ä¸€å®šå¯ä»¥å¸®åŠ©ä½ æ¶ˆé™¤æˆ–è€…åŒ…è£…é‚£äº›é’ˆå¯¹ç‰¹å®šåŽ‚å•†çš„ SQL ä»£ç ï¼Œè€Œä¸”å¸®åŠ©ä½ ç»“"
-"æžœé›†ä»Žè¡¨æ ¼å¼çš„è¡¨ç¤ºå½¢å¼è½¬æ¢åˆ°ä¸€ç³»åˆ—çš„å¯¹è±¡ä¸­åŽ»ã€‚"
+#, no-c-format
+msgid "Hibernate's goal is to relieve the developer from 95 percent of common data persistence related programming tasks. Hibernate may not be the best solution for data-centric applications that only use stored-procedures to implement the business logic in the database, it is most useful with object-oriented domain models and business logic in the Java-based middle-tier. However, Hibernate can certainly help you to remove or encapsulate vendor-specific SQL code and will help with the common task of result set translation from a tabular representation to a graph of objects."
+msgstr "Hibernate çš„ç›®æ ‡æ˜¯å¯¹äºŽå¼€å‘è€…é€šå¸¸çš„æ•°æ®æŒä¹…åŒ–ç›¸å…³çš„ç¼–ç¨‹ä»»åŠ¡ï¼Œè§£æ”¾å…¶ä¸­çš„ 95%。对于以数据为中心的程序来说，它们往往只在数据库中使用存储过程来实现商业逻辑，Hibernate 可能不是最好的解决方案；对于那些在基于 Java 的中间层应用中，它们实现面向对象的业务模型和商业逻辑的应用，Hibernate æ˜¯æœ€æœ‰ç”¨çš„ã€‚ä¸ç®¡æ€Žæ ·ï¼ŒHibernate ä¸€å®šå¯ä»¥å¸®åŠ©ä½ æ¶ˆé™¤æˆ–è€…åŒ…è£…é‚£äº›é’ˆå¯¹ç‰¹å®šåŽ‚å•†çš„ SQL ä»£ç ï¼Œè€Œä¸”å¸®åŠ©ä½ ç»“æžœé›†ä»Žè¡¨æ ¼å¼çš„è¡¨ç¤ºå½¢å¼è½¬æ¢åˆ°ä¸€ç³»åˆ—çš„å¯¹è±¡ä¸­åŽ»ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you are new to Hibernate and Object/Relational Mapping or even Java, "
-"please follow these steps:"
-msgstr ""
-"å¦‚æžœä½ å¯¹ Hibernate 和对象/å…³ç³»åž‹æ•°æ®åº“æ˜ å°„è¿˜æ˜¯ä¸ªæ–°æ‰‹ï¼Œç”šè‡³å¯¹ Java 也不熟悉，"
-"è¯·æŒ‰ç…§ä¸‹é¢çš„æ­¥éª¤æ¥å­¦ä¹ ã€‚"
+msgid "If you are new to Hibernate and Object/Relational Mapping or even Java, please follow these steps:"
+msgstr "å¦‚æžœä½ å¯¹ Hibernate 和对象/å…³ç³»åž‹æ•°æ®åº“æ˜ å°„è¿˜æ˜¯ä¸ªæ–°æ‰‹ï¼Œç”šè‡³å¯¹ Java ä¹Ÿä¸ç†Ÿæ‚‰ï¼Œè¯·æŒ‰ç…§ä¸‹é¢çš„æ­¥éª¤æ¥å­¦ä¹ ã€‚"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Read <xref linkend=\"tutorial\" /> for a tutorial with step-by-step "
-"instructions. The source code for the tutorial is included in the "
-"distribution in the <literal>doc/reference/tutorial/</literal> directory."
-msgstr ""
-"阅读 <xref linkend=\"Introduction_to_Hibernate\"/>，这是一篇包含详细的逐步知"
-"é“çš„æŒ‡å—ã€‚æœ¬æŒ‡å—çš„æºä»£ç åŒ…å«åœ¨å‘è¡ŒåŒ…é‡Œï¼Œä½ å¯ä»¥åœ¨ <literal>doc/reference/"
-"tutorial/</literal> 目录下找到。"
+#, no-c-format
+msgid "Read <xref linkend=\"tutorial\" /> for a tutorial with step-by-step instructions. The source code for the tutorial is included in the distribution in the <literal>doc/reference/tutorial/</literal> directory."
+msgstr "阅读 <xref linkend=\"Introduction_to_Hibernate\"/>ï¼Œè¿™æ˜¯ä¸€ç¯‡åŒ…å«è¯¦ç»†çš„é€æ­¥çŸ¥é“çš„æŒ‡å—ã€‚æœ¬æŒ‡å—çš„æºä»£ç åŒ…å«åœ¨å‘è¡ŒåŒ…é‡Œï¼Œä½ å¯ä»¥åœ¨ <literal>doc/reference/tutorial/</literal> 目录下找到。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Read <xref linkend=\"architecture\" /> to understand the environments where "
-"Hibernate can be used."
-msgstr ""
-"阅读 <xref linkend=\"Architecture\"/> 来理解 Hibernate 可以使用的环境。"
+#, no-c-format
+msgid "Read <xref linkend=\"architecture\" /> to understand the environments where Hibernate can be used."
+msgstr "阅读 <xref linkend=\"Architecture\"/> 来理解 Hibernate 可以使用的环境。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"View the <literal>eg/</literal> directory in the Hibernate distribution. It "
-"contains a simple standalone application. Copy your JDBC driver to the "
-"<literal>lib/</literal> directory and edit <literal>etc/hibernate."
-"properties</literal>, specifying correct values for your database. From a "
-"command prompt in the distribution directory, type <literal>ant eg</literal> "
-"(using Ant), or under Windows, type <literal>build eg</literal>."
-msgstr ""
-"查看 Hibernate 发行包中的 <literal>eg/</literal> 目录，里面有个一简单的独立运"
-"è¡Œçš„ç¨‹åºã€‚æŠŠä½ çš„ JDBC 驱动复制到 <literal>lib/</literal> 目录并修改一下 "
-"<literal>etc/hibernate.properties</literal>，指定数据库的信息。然后进入命令"
-"行，切换到发行包的目录，输入 <literal>ant eg</literal>（使用 Ant），或者在 "
-"Windows 系统下使用 <literal>build eg</literal>。"
+#, no-c-format
+msgid "View the <literal>eg/</literal> directory in the Hibernate distribution. It contains a simple standalone application. Copy your JDBC driver to the <literal>lib/</literal> directory and edit <literal>etc/hibernate.properties</literal>, specifying correct values for your database. From a command prompt in the distribution directory, type <literal>ant eg</literal> (using Ant), or under Windows, type <literal>build eg</literal>."
+msgstr "查看 Hibernate 发行包中的 <literal>eg/</literal> ç›®å½•ï¼Œé‡Œé¢æœ‰ä¸ªä¸€ç®€å•çš„ç‹¬ç«‹è¿è¡Œçš„ç¨‹åºã€‚æŠŠä½ çš„ JDBC 驱动复制到 <literal>lib/</literal> 目录并修改一下 <literal>etc/hibernate.properties</literal>，指定数据库的信息。然后进入命令行，切换到发行包的目录，输入 <literal>ant eg</literal>（使用 Ant），或者在 Windows 系统下使用 <literal>build eg</literal>。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Use this reference documentation as your primary source of information. "
-"Consider reading <emphasis>Java Persistence with Hibernate</emphasis> "
-"(http://www.manning.com/bauer2) if you need more help with application "
-"design, or if you prefer a step-by-step tutorial. Also visit http://"
-"caveatemptor.hibernate.org and download the example application for Java "
-"Persistence with Hibernate."
-msgstr ""
-"æŠŠè¿™ä»½æ–‡æ¡£ä½œä¸ºä½ å­¦ä¹ çš„ä¸»è¦ä¿¡æ¯æ¥æºã€‚å¦‚æžœä½ éœ€è¦åº”ç”¨ç¨‹åºè®¾è®¡æ–¹é¢çš„å¸®åŠ©æˆ–è€…ä½ å¸Œ"
-"æœ›æœ‰ä¸€ä¸ªæŒ‰éƒ¨å°±ç­çš„æŒ‡å—ï¼Œä½ å¯ä»¥è€ƒè™‘é˜…è¯» <emphasis>Hibernate in Action</"
-"emphasis>（http://www.manning.com/bauerï¼‰ã€‚ä½ ä¹Ÿå¯ä»¥è®¿é—®http://caveatemptor."
-"hibernate.org 并下载 Hibernate 的示例程序。"
+#, no-c-format
+msgid "Use this reference documentation as your primary source of information. Consider reading <emphasis>Java Persistence with Hibernate</emphasis> (http://www.manning.com/bauer2) if you need more help with application design, or if you prefer a step-by-step tutorial. Also visit http://caveatemptor.hibernate.org and download the example application for Java Persistence with Hibernate."
+msgstr "æŠŠè¿™ä»½æ–‡æ¡£ä½œä¸ºä½ å­¦ä¹ çš„ä¸»è¦ä¿¡æ¯æ¥æºã€‚å¦‚æžœä½ éœ€è¦åº”ç”¨ç¨‹åºè®¾è®¡æ–¹é¢çš„å¸®åŠ©æˆ–è€…ä½ å¸Œæœ›æœ‰ä¸€ä¸ªæŒ‰éƒ¨å°±ç­çš„æŒ‡å—ï¼Œä½ å¯ä»¥è€ƒè™‘é˜…è¯» <emphasis>Hibernate in Action</emphasis>（http://www.manning.com/bauerï¼‰ã€‚ä½ ä¹Ÿå¯ä»¥è®¿é—® http://caveatemptor.hibernate.org 并下载 Hibernate 的示例程序。"
 
 #. Tag: para
 #, no-c-format
@@ -131,45 +66,21 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Third party demos, examples, and tutorials are linked on the Hibernate "
-"website."
+msgid "Third party demos, examples, and tutorials are linked on the Hibernate website."
 msgstr "在 Hibernate 网站上还有第三方的演示、示例和教程的链接。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The Community Area on the Hibernate website is a good resource for design "
-"patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, "
-"etc.)."
-msgstr ""
-"Hibernate 网站的社区是讨论关于设计模式以及很多整合方案（Tomcat、JBoss AS、"
-"Struts、EJB 等）的好地方。"
+msgid "The Community Area on the Hibernate website is a good resource for design patterns and various integration solutions (Tomcat, JBoss AS, Struts, EJB, etc.)."
+msgstr "Hibernate 网站的社区是讨论关于设计模式以及很多整合方案（Tomcat、JBoss AS、Struts、EJB 等）的好地方。"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"If you have questions, use the user forum linked on the Hibernate website. "
-"We also provide a JIRA issue tracking system for bug reports and feature "
-"requests. If you are interested in the development of Hibernate, join the "
-"developer mailing list. If you are interested in translating this "
-"documentation into your language, contact us on the developer mailing list."
-msgstr ""
-"å¦‚æžœä½ æœ‰ä»»ä½•é—®é¢˜ï¼Œè¯·ä½¿ç”¨ Hibernate 网站上链接的用户论坛。我们也提供一个 JIRA "
-"问题追踪系统，来搜集 bug 报告和新的功能请求。如果对开发 Hibernate 有兴趣，请"
-"åŠ å…¥å¼€å‘è€…çš„é‚®ä»¶åˆ—è¡¨ã€‚å¦‚æžœä½ å¯¹ç¿»è¯‘æœ¬æ–‡æ¡£æ„Ÿå…´è¶£ï¼Œè¯·é€šè¿‡å¼€å‘è€…çš„é‚®ä»¶åˆ—è¡¨æ¥è”ç³»"
-"我们。"
+#, no-c-format
+msgid "If you have questions, use the user forum linked on the Hibernate website. We also provide a JIRA issue tracking system for bug reports and feature requests. If you are interested in the development of Hibernate, join the developer mailing list. If you are interested in translating this documentation into your language, contact us on the developer mailing list."
+msgstr "å¦‚æžœä½ æœ‰ä»»ä½•é—®é¢˜ï¼Œè¯·ä½¿ç”¨ Hibernate 网站上链接的用户论坛。我们也提供一个 JIRA 问题追踪系统，来搜集 bug 报告和新的功能请求。如果对开发 Hibernate æœ‰å…´è¶£ï¼Œè¯·åŠ å…¥å¼€å‘è€…çš„é‚®ä»¶åˆ—è¡¨ã€‚å¦‚æžœä½ å¯¹ç¿»è¯‘æœ¬æ–‡æ¡£æ„Ÿå…´è¶£ï¼Œè¯·é€šè¿‡å¼€å‘è€…çš„é‚®ä»¶åˆ—è¡¨æ¥è”ç³»æˆ‘ä»¬ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Commercial development support, production support, and training for "
-"Hibernate is available through JBoss Inc. (see http://www.hibernate.org/"
-"SupportTraining/). Hibernate is a Professional Open Source project and a "
-"critical component of the JBoss Enterprise Middleware System (JEMS) suite of "
-"products."
-msgstr ""
-"商业开发、产品支持和 Hibernate 培训可以通过 JBoss Inc. 获得（请查阅： http://"
-"www.hibernate.org/SupportTraining/）。Hibernate 是一个专业的开源项目，也是 "
-"JBoss 企业级中间件系统（JBoss Enterprise Middleware System，JEMSï¼‰é‡Œçš„ä¸€ä¸ªæ ¸"
-"心组件。  "
+msgid "Commercial development support, production support, and training for Hibernate is available through JBoss Inc. (see http://www.hibernate.org/SupportTraining/). Hibernate is a Professional Open Source project and a critical component of the JBoss Enterprise Middleware System (JEMS) suite of products."
+msgstr "商业开发、产品支持和 Hibernate 培训可以通过 JBoss Inc. 获得（请查阅： http://www.hibernate.org/SupportTraining/）。Hibernate 是一个专业的开源项目，也是 JBoss 企业级中间件系统（JBoss Enterprise Middleware System，JEMSï¼‰é‡Œçš„ä¸€ä¸ªæ ¸å¿ƒç»„ä»¶ã€‚  "
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_sql.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_sql.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_sql.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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: 2009-12-04 15:21+1000\n"
+"PO-Revision-Date: 2009-12-11 09:55+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -535,9 +535,9 @@
 msgstr "Hibernate3 能够使用定制的 SQL 语句来执行 create，update å’Œ delete 操作。在 Hibernate 中，持久化的类和集合已经包含了一套配置期产生的语句（insertsql，deletesql，updatesql ç­‰ç­‰ï¼‰ï¼Œè¿™äº›æ˜ å°„æ ‡è®° <literal>&lt;sql-insert&gt;</literal>，<literal>&lt;sql-delete&gt;</literal> å’Œ <literal>&lt;sql-update&gt;</literal> 重载了这些语句。"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "The SQL is directly executed in your database, so you can use any dialect you like. This will reduce the portability of your mapping if you use database specific SQL."
-msgstr "这些 SQL ç›´æŽ¥åœ¨ä½ çš„æ•°æ®åº“é‡Œæ‰§è¡Œï¼Œæ‰€ä»¥ä½ å¯ä»¥è‡ªç”±çš„ä½¿ç”¨ä½ å–œæ¬¢çš„ä»»æ„è¯­æ³•ã€‚ä½†å¦‚æžœä½ ä½¿ç”¨æ•°æ®åº“ç‰¹å®šçš„è¯­æ³•ï¼Œè¿™å½“ç„¶ä¼šé™ä½Žä½ æ˜ å°„çš„å¯ç§»æ¤æ€§ã€‚"
+msgstr "这些 SQL ç›´æŽ¥åœ¨ä½ çš„æ•°æ®åº“é‡Œæ‰§è¡Œï¼Œæ‰€ä»¥ä½ å¯ä»¥è‡ªç”±çš„ä½¿ç”¨ä½ å–œæ¬¢çš„ä»»æ„è¯­æ³•ã€‚ä½†å¦‚æžœä½ ä½¿ç”¨æ•°æ®åº“ç‰¹å®šçš„è¯­æ³•ï¼Œè¿™å½“ç„¶ä¼šé™ä½Žä½ æ˜ å°„çš„å¯ç§»æ¤æ€§ã€‚ "
 
 #. Tag: para
 #, no-c-format
@@ -545,19 +545,19 @@
 msgstr "如果设定 <literal>callable</literal>，则能够支持存储过程了。"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "The order of the positional parameters is vital, as they must be in the same sequence as Hibernate expects them."
-msgstr "参数的位置顺序是非常重要的，他们必须和 Hibernate 所期待的顺序相同。"
+msgstr "参数的位置顺序是非常重要的，他们必须和 Hibernate 所期待的顺序相同。 "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "You can view the expected order by enabling debug logging for the <literal>org.hibernate.persister.entity</literal> level. With this level enabled, Hibernate will print out the static SQL that is used to create, update, delete etc. entities. To view the expected sequence, do not include your custom SQL in the mapping files, as this will override the Hibernate generated static SQL."
-msgstr "ä½ èƒ½å¤Ÿé€šè¿‡è®¾å®šæ—¥å¿—è°ƒè¯•çº§åˆ«ä¸º <literal>org.hiberante.persister.entity</literal> 来查看 Hibernate 所期待的顺序。在这个级别下，Hibernate 将会打印出create，update å’Œ delete 实体的静态 SQL。（如果想看到预计的顺序。记得不要将定制 SQL åŒ…å«åœ¨æ˜ å°„æ–‡ä»¶é‡Œï¼Œå› ä¸ºä»–ä»¬ä¼šé‡è½½ Hibernate 生成的静态 SQL。）"
+msgstr "ä½ èƒ½å¤Ÿé€šè¿‡è®¾å®šæ—¥å¿—è°ƒè¯•çº§åˆ«ä¸º <literal>org.hiberante.persister.entity</literal> 来查看 Hibernate 所期待的顺序。在这个级别下，Hibernate 将会打印出create，update å’Œ delete 实体的静态 SQL。（如果想看到预计的顺序。记得不要将定制 SQL åŒ…å«åœ¨æ˜ å°„æ–‡ä»¶é‡Œï¼Œå› ä¸ºä»–ä»¬ä¼šé‡è½½ Hibernate 生成的静态 SQL。） "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "The stored procedures are in most cases required to return the number of rows inserted, updated and deleted, as Hibernate has some runtime checks for the success of the statement. Hibernate always registers the first statement parameter as a numeric output parameter for the CUD operations:"
-msgstr "åœ¨å¤§å¤šæ•°æƒ…å†µä¸‹ï¼ˆæœ€å¥½è¿™ä¹ˆåšï¼‰ï¼Œå­˜å‚¨è¿‡ç¨‹éœ€è¦è¿”å›žæ’å…¥ï¼æ›´æ–°ï¼åˆ é™¤çš„è¡Œæ•°ï¼Œå› ä¸º Hibernate 对语句的成功执行有些运行时的检查。Hibernate 常会把进行 CUD 操作的语句的第一个参数注册为一个数值型输出参数。"
+msgstr "åœ¨å¤§å¤šæ•°æƒ…å†µä¸‹ï¼ˆæœ€å¥½è¿™ä¹ˆåšï¼‰ï¼Œå­˜å‚¨è¿‡ç¨‹éœ€è¦è¿”å›žæ’å…¥ï¼æ›´æ–°ï¼åˆ é™¤çš„è¡Œæ•°ï¼Œå› ä¸º Hibernate 对语句的成功执行有些运行时的检查。Hibernate 常会把进行 CUD 操作的语句的第一个参数注册为一个数值型输出参数："
 
 #. Tag: title
 #, no-c-format
@@ -565,14 +565,14 @@
 msgstr "定制装载 SQL"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "You can also declare your own SQL (or HQL) queries for entity loading:"
-msgstr "ä½ å¯èƒ½éœ€è¦å£°æ˜Žä½ è‡ªå·±çš„ SQL（或 HQL）来装载实体"
+msgstr "ä½ å¯èƒ½éœ€è¦å£°æ˜Žä½ è‡ªå·±çš„ SQL（或 HQL）来装载实体："
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "This is just a named query declaration, as discussed earlier. You can reference this named query in a class mapping:"
-msgstr "è¿™åªæ˜¯ä¸€ä¸ªå‰é¢è®¨è®ºè¿‡çš„å‘½åæŸ¥è¯¢å£°æ˜Žï¼Œä½ å¯ä»¥åœ¨ç±»æ˜ å°„é‡Œå¼•ç”¨è¿™ä¸ªå‘½åæŸ¥è¯¢ã€‚"
+msgstr "è¿™åªæ˜¯ä¸€ä¸ªå‰é¢è®¨è®ºè¿‡çš„å‘½åæŸ¥è¯¢å£°æ˜Žï¼Œä½ å¯ä»¥åœ¨ç±»æ˜ å°„é‡Œå¼•ç”¨è¿™ä¸ªå‘½åæŸ¥è¯¢ï¼š"
 
 #. Tag: para
 #, no-c-format
@@ -580,14 +580,14 @@
 msgstr "这也可以用于存储过程"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "You can even define a query for collection loading:"
-msgstr "ä½ ç”šè‡³å¯ä»¥å®šä¸€ä¸ªç”¨äºŽé›†åˆè£…è½½çš„æŸ¥è¯¢ï¼š"
+msgstr "ä½ ç”šè‡³å¯ä»¥å®šä¸€ä¸ªç”¨äºŽé›†åˆè£…è½½çš„æŸ¥è¯¢ï¼š "
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "You can also define an entity loader that loads a collection by join fetching:"
-msgstr "ä½ ç”šè‡³è¿˜å¯ä»¥å®šä¹‰ä¸€ä¸ªå®žä½“è£…è½½å™¨ï¼Œå®ƒé€šè¿‡è¿žæŽ¥æŠ“å–è£…è½½ä¸€ä¸ªé›†åˆï¼š"
+msgstr "ä½ ç”šè‡³è¿˜å¯ä»¥å®šä¹‰ä¸€ä¸ªå®žä½“è£…è½½å™¨ï¼Œå®ƒé€šè¿‡è¿žæŽ¥æŠ“å–è£…è½½ä¸€ä¸ªé›†åˆï¼š "
 
 #, fuzzy
 #~ msgid ""

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/transactions.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -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: 2009-11-27 14:11+1000\n"
+"PO-Revision-Date: 2009-12-11 09:56+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -21,54 +21,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The most important point about Hibernate and concurrency control is that it "
-"is easy to understand. Hibernate directly uses JDBC connections and JTA "
-"resources without adding any additional locking behavior. It is recommended "
-"that you spend some time with the JDBC, ANSI, and transaction isolation "
-"specification of your database management system."
-msgstr ""
-"Hibernate 的事务和并发控制很容易掌握。Hibernate 直接使用 JDBC 连接和 JTA 资"
-"æºï¼Œä¸æ·»åŠ ä»»ä½•é™„åŠ é”å®šè¡Œä¸ºã€‚æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ èŠ±ç‚¹æ—¶é—´äº†è§£ JDBC 编程，ANSI SQL 查"
-"è¯¢è¯­è¨€å’Œä½ ä½¿ç”¨çš„æ•°æ®åº“ç³»ç»Ÿçš„äº‹åŠ¡éš”ç¦»è§„èŒƒã€‚ "
+msgid "The most important point about Hibernate and concurrency control is that it is easy to understand. Hibernate directly uses JDBC connections and JTA resources without adding any additional locking behavior. It is recommended that you spend some time with the JDBC, ANSI, and transaction isolation specification of your database management system."
+msgstr "Hibernate 的事务和并发控制很容易掌握。Hibernate 直接使用 JDBC 连接和 JTA èµ„æºï¼Œä¸æ·»åŠ ä»»ä½•é™„åŠ é”å®šè¡Œä¸ºã€‚æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ èŠ±ç‚¹æ—¶é—´äº†è§£ JDBC 编程，ANSI SQL æŸ¥è¯¢è¯­è¨€å’Œä½ ä½¿ç”¨çš„æ•°æ®åº“ç³»ç»Ÿçš„äº‹åŠ¡éš”ç¦»è§„èŒƒã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate does not lock objects in memory. Your application can expect the "
-"behavior as defined by the isolation level of your database transactions. "
-"Through <literal>Session</literal>, which is also a transaction-scoped "
-"cache, Hibernate provides repeatable reads for lookup by identifier and "
-"entity queries and not reporting queries that return scalar values."
-msgstr ""
-"Hibernate ä¸é”å®šå†…å­˜ä¸­çš„å¯¹è±¡ã€‚ä½ çš„åº”ç”¨ç¨‹åºä¼šæŒ‰ç…§ä½ çš„æ•°æ®åº“äº‹åŠ¡çš„éš”ç¦»çº§åˆ«è§„å®š"
-"çš„é‚£æ ·è¿ä½œã€‚å¹¸äºæœ‰äº† <literal>Session</literal>，使得 Hibernate é€šè¿‡æ ‡è¯†ç¬¦æŸ¥"
-"æ‰¾ï¼Œå’Œå®žä½“æŸ¥è¯¢ï¼ˆä¸æ˜¯è¿”å›žæ ‡é‡å€¼çš„æŠ¥è¡¨æŸ¥è¯¢ï¼‰æä¾›äº†å¯é‡å¤çš„è¯»å–ï¼ˆRepeatable "
-"reads）功能，<literal>Session</literal> 同时也是事务范围内的缓存（cache）。 "
+msgid "Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Through <literal>Session</literal>, which is also a transaction-scoped cache, Hibernate provides repeatable reads for lookup by identifier and entity queries and not reporting queries that return scalar values."
+msgstr "Hibernate ä¸é”å®šå†…å­˜ä¸­çš„å¯¹è±¡ã€‚ä½ çš„åº”ç”¨ç¨‹åºä¼šæŒ‰ç…§ä½ çš„æ•°æ®åº“äº‹åŠ¡çš„éš”ç¦»çº§åˆ«è§„å®šçš„é‚£æ ·è¿ä½œã€‚å¹¸äºæœ‰äº† <literal>Session</literal>，使得 Hibernate é€šè¿‡æ ‡è¯†ç¬¦æŸ¥æ‰¾ï¼Œå’Œå®žä½“æŸ¥è¯¢ï¼ˆä¸æ˜¯è¿”å›žæ ‡é‡å€¼çš„æŠ¥è¡¨æŸ¥è¯¢ï¼‰æä¾›äº†å¯é‡å¤çš„è¯»å–ï¼ˆRepeatable reads）功能，<literal>Session</literal> 同时也是事务范围内的缓存（cache）。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In addition to versioning for automatic optimistic concurrency control, "
-"Hibernate also offers, using the <literal>SELECT FOR UPDATE</literal> "
-"syntax, a (minor) API for pessimistic locking of rows. Optimistic "
-"concurrency control and this API are discussed later in this chapter."
-msgstr ""
-"除了对自动乐观并发控制提供版本管理，针对行级悲观锁定，Hibernate 也提供了辅助"
-"的（较小的）API，它使用了 <literal>SELECT FOR UPDATE</literal> 的 SQL 语法。"
-"æœ¬ç« åŽé¢ä¼šè®¨è®ºä¹è§‚å¹¶å‘æŽ§åˆ¶å’Œè¿™ä¸ªAPI。 "
+msgid "In addition to versioning for automatic optimistic concurrency control, Hibernate also offers, using the <literal>SELECT FOR UPDATE</literal> syntax, a (minor) API for pessimistic locking of rows. Optimistic concurrency control and this API are discussed later in this chapter."
+msgstr "除了对自动乐观并发控制提供版本管理，针对行级悲观锁定，Hibernate 也提供了辅助的（较小的）API，它使用了 <literal>SELECT FOR UPDATE</literal> çš„ SQL è¯­æ³•ã€‚æœ¬ç« åŽé¢ä¼šè®¨è®ºä¹è§‚å¹¶å‘æŽ§åˆ¶å’Œè¿™ä¸ªAPI。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The discussion of concurrency control in Hibernate begins with the "
-"granularity of <literal>Configuration</literal>, <literal>SessionFactory</"
-"literal>, and <literal>Session</literal>, as well as database transactions "
-"and long conversations."
-msgstr ""
-"我们从 <literal>Configuration</literal>层、<literal>SessionFactory</literal> "
-"层，和 <literal>Session</literal> 层开始讨论 Hibernate 的并行控制、数据库事务"
-"和应用程序的长事务。 "
+msgid "The discussion of concurrency control in Hibernate begins with the granularity of <literal>Configuration</literal>, <literal>SessionFactory</literal>, and <literal>Session</literal>, as well as database transactions and long conversations."
+msgstr "我们从 <literal>Configuration</literal>层、<literal>SessionFactory</literal> 层，和 <literal>Session</literal> 层开始讨论 Hibernate 的并行控制、数据库事务和应用程序的长事务。 "
 
 #. Tag: title
 #, no-c-format
@@ -77,58 +46,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe "
-"object, intended to be shared by all application threads. It is created "
-"once, usually on application startup, from a <literal>Configuration</"
-"literal> instance."
-msgstr ""
-"<literal>SessionFactory</literal> 对象的创建代价很昂贵，它是线程安全的对象，"
-"它为所有的应用程序线程所共享。它只创建一次，通常是在应用程序启动的时候，由一"
-"个 <literal>Configuraion</literal> 的实例来创建。 "
+msgid "A <literal>SessionFactory</literal> is an expensive-to-create, threadsafe object, intended to be shared by all application threads. It is created once, usually on application startup, from a <literal>Configuration</literal> instance."
+msgstr "<literal>SessionFactory</literal> 对象的创建代价很昂贵，它是线程安全的对象，它为所有的应用程序线程所共享。它只创建一次，通常是在应用程序启动的时候，由一个 <literal>Configuraion</literal> 的实例来创建。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A <literal>Session</literal> is an inexpensive, non-threadsafe object that "
-"should be used once and then discarded for: a single request, a conversation "
-"or a single unit of work. A <literal>Session</literal> will not obtain a "
-"JDBC <literal>Connection</literal>, or a <literal>Datasource</literal>, "
-"unless it is needed. It will not consume any resources until used."
-msgstr ""
-"<literal>Session</literal> 对象的创建代价比较小，是非线程安全的，对于单个请"
-"求，单个会话、单个的 工作单元而言，它只被使用一次，然后就丢弃。只有在需要的时"
-"候，一个 <literal>Session</literal> 对象 才会获取一个 JDBC 的 "
-"<literal>Connection</literal>（或一个<literal>Datasource</literal>ï¼‰å¯¹è±¡ï¼Œå› "
-"此假若不使用的时候它不消费任何资源。 "
+msgid "A <literal>Session</literal> is an inexpensive, non-threadsafe object that should be used once and then discarded for: a single request, a conversation or a single unit of work. A <literal>Session</literal> will not obtain a JDBC <literal>Connection</literal>, or a <literal>Datasource</literal>, unless it is needed. It will not consume any resources until used."
+msgstr "<literal>Session</literal> 对象的创建代价比较小，是非线程安全的，对于单个请求，单个会话、单个的 工作单元而言，它只被使用一次，然后就丢弃。只有在需要的时候，一个 <literal>Session</literal> 对象 才会获取一个 JDBC çš„ <literal>Connection</literal>（或一个<literal>Datasource</literal>ï¼‰å¯¹è±¡ï¼Œå› æ­¤å‡è‹¥ä¸ä½¿ç”¨çš„æ—¶å€™å®ƒä¸æ¶ˆè´¹ä»»ä½•èµ„æºã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In order to reduce lock contention in the database, a database transaction "
-"has to be as short as possible. Long database transactions will prevent your "
-"application from scaling to a highly concurrent load. It is not recommended "
-"that you hold a database transaction open during user think time until the "
-"unit of work is complete."
-msgstr ""
-"此外我们还要考虑数据库事务。数据库事务应该尽可能的短，降低数据库中的锁争用。"
-"æ•°æ®åº“é•¿äº‹åŠ¡ä¼šé˜»æ­¢ä½ çš„åº”ç”¨ç¨‹åºæ‰©å±•åˆ°é«˜çš„å¹¶å‘è´Ÿè½½ã€‚å› æ­¤ï¼Œå‡è‹¥åœ¨ç”¨æˆ·æ€è€ƒæœŸé—´è®©"
-"数据库事务开着，直到整个工作单元完成才关闭这个事务，这绝不是一个好的设计。 "
+msgid "In order to reduce lock contention in the database, a database transaction has to be as short as possible. Long database transactions will prevent your application from scaling to a highly concurrent load. It is not recommended that you hold a database transaction open during user think time until the unit of work is complete."
+msgstr "æ­¤å¤–æˆ‘ä»¬è¿˜è¦è€ƒè™‘æ•°æ®åº“äº‹åŠ¡ã€‚æ•°æ®åº“äº‹åŠ¡åº”è¯¥å°½å¯èƒ½çš„çŸ­ï¼Œé™ä½Žæ•°æ®åº“ä¸­çš„é”äº‰ç”¨ã€‚æ•°æ®åº“é•¿äº‹åŠ¡ä¼šé˜»æ­¢ä½ çš„åº”ç”¨ç¨‹åºæ‰©å±•åˆ°é«˜çš„å¹¶å‘è´Ÿè½½ã€‚å› æ­¤ï¼Œå‡è‹¥åœ¨ç”¨æˆ·æ€è€ƒæœŸé—´è®©æ•°æ®åº“äº‹åŠ¡å¼€ç€ï¼Œç›´åˆ°æ•´ä¸ªå·¥ä½œå•å…ƒå®Œæˆæ‰å…³é—­è¿™ä¸ªäº‹åŠ¡ï¼Œè¿™ç»ä¸æ˜¯ä¸€ä¸ªå¥½çš„è®¾è®¡ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"What is the scope of a unit of work? Can a single Hibernate "
-"<literal>Session</literal> span several database transactions, or is this a "
-"one-to-one relationship of scopes? When should you open and close a "
-"<literal>Session</literal> and how do you demarcate the database transaction "
-"boundaries? These questions are addressed in the following sections."
-msgstr ""
-"一个操作单元（Unit of work）的范围是多大？单个的 Hibernate <literal>Session</"
-"literal> 能跨越多个数据库事务吗？还是一个 <literal>Session</literal> 的作用范"
-"围对应一个数据库事务的范围？应该何时打开 <literal>Session</literal>，何时关"
-"é—­ <literal>Session</literal>ï¼Œä½ åˆå¦‚ä½•åˆ’åˆ†æ•°æ®åº“äº‹åŠ¡çš„è¾¹ç•Œå‘¢ï¼Ÿæˆ‘ä»¬å°†åœ¨åŽç»­ç« "
-"节解决这些问题。"
+msgid "What is the scope of a unit of work? Can a single Hibernate <literal>Session</literal> span several database transactions, or is this a one-to-one relationship of scopes? When should you open and close a <literal>Session</literal> and how do you demarcate the database transaction boundaries? These questions are addressed in the following sections."
+msgstr "一个操作单元（Unit of work）的范围是多大？单个的 Hibernate <literal>Session</literal> 能跨越多个数据库事务吗？还是一个 <literal>Session</literal> 的作用范围对应一个数据库事务的范围？应该何时打开 <literal>Session</literal>，何时关闭 <literal>Session</literal>ï¼Œä½ åˆå¦‚ä½•åˆ’åˆ†æ•°æ®åº“äº‹åŠ¡çš„è¾¹ç•Œå‘¢ï¼Ÿæˆ‘ä»¬å°†åœ¨åŽç»­ç« èŠ‚è§£å†³è¿™äº›é—®é¢˜ã€‚"
 
 #. Tag: title
 #, no-c-format
@@ -136,137 +70,34 @@
 msgstr "操作单元（Unit of work）"
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"First, let's define a unit of work. A unit of work is a design pattern "
-"described by Martin Fowler as <quote> [maintaining] a list of objects "
-"affected by a business transaction and coordinates the writing out of "
-"changes and the resolution of concurrency problems. </quote><citation>PoEAA</"
-"citation> In other words, its a series of operations we wish to carry out "
-"against the database together. Basically, it is a transaction, though "
-"fulfilling a unit of work will often span multiple physical database "
-"transactions (see <xref linkend=\"transactions-basics-apptx\" />). So really "
-"we are talking about a more abstract notion of a transaction. The term "
-"\"business transaction\" is also sometimes used in lieu of unit of work."
-msgstr ""
-"首先，让我们定义一个工作单元（unit of work）。工作单元是一个设计模式，Martin "
-"Fowler 把它描述为 <quote> [maintaining] a list of objects affected by a "
-"business transaction and coordinates the writing out of changes and the "
-"resolution of concurrency problems. </quote><citation>PoEAA</citation> 换句话"
-"说，它是我们希望对数据库执行的一系列操作。基本上，它是一个事务，虽然完成一个"
-"工作单元经常将跨越多个物理数据库事务（请参考 <xref linkend=\"transactions-"
-"basics-apptx\"/>）。所以，实际上我们在讨论一个更抽象的事务概念。术语 "
-"\"business transaction\" 有时也和工作单元一起使用。"
+#, no-c-format
+msgid "First, let's define a unit of work. A unit of work is a design pattern described by Martin Fowler as <quote> [maintaining] a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems. </quote><citation>PoEAA</citation> In other words, its a series of operations we wish to carry out against the database together. Basically, it is a transaction, though fulfilling a unit of work will often span multiple physical database transactions (see <xref linkend=\"transactions-basics-apptx\" />). So really we are talking about a more abstract notion of a transaction. The term \"business transaction\" is also sometimes used in lieu of unit of work."
+msgstr "首先，让我们定义一个工作单元（unit of work）。工作单元是一个设计模式，Martin Fowler 把它描述为 <quote> [maintaining] a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems. </quote><citation>PoEAA</citation> 换句话说，它是我们希望对数据库执行的一系列操作。基本上，它是一个事务，虽然完成一个工作单元经常将跨越多个物理数据库事务（请参考 <xref linkend=\"transactions-basics-apptx\"/>）。所以，实际上我们在讨论一个更抽象的事务概念。术语 \"business transaction\" 有时也和工作单元一起使用。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Do not use the <emphasis>session-per-operation</emphasis> antipattern: do "
-"not open and close a <literal>Session</literal> for every simple database "
-"call in a single thread. The same is true for database transactions. "
-"Database calls in an application are made using a planned sequence; they are "
-"grouped into atomic units of work. This also means that auto-commit after "
-"every single SQL statement is useless in an application as this mode is "
-"intended for ad-hoc SQL console work. Hibernate disables, or expects the "
-"application server to disable, auto-commit mode immediately. Database "
-"transactions are never optional. All communication with a database has to "
-"occur inside a transaction. Auto-commit behavior for reading data should be "
-"avoided, as many small transactions are unlikely to perform better than one "
-"clearly defined unit of work. The latter is also more maintainable and "
-"extensible."
-msgstr ""
-"首先，别用 <emphasis>session-per-operation</emphasis> 这种反模式了，也就是"
-"说，在单个线程中， ä¸è¦å› ä¸ºä¸€æ¬¡ç®€å•çš„æ•°æ®åº“è°ƒç”¨ï¼Œå°±æ‰“å¼€å’Œå…³é—­ä¸€æ¬¡ "
-"<literal>Session</literal>！数据库事务也是如此。 应用程序中的数据库调用是按照"
-"计划好的次序，分组为原子的操作单元。（注意，这也意味着，应用程 序中，在单个"
-"的 SQL 语句发送之后，自动事务提交（auto-commit）模式失效了。这种模式专门为SQL"
-"控制台操作设计的。 Hibernate 禁止立即自动事务提交模式，或者期望应用服务器禁止"
-"ç«‹å³è‡ªåŠ¨äº‹åŠ¡æäº¤æ¨¡å¼ã€‚ï¼‰æ•°æ®åº“äº‹åŠ¡ç»ä¸æ˜¯å¯æœ‰å¯æ— çš„ï¼Œä»»ä½•ä¸Žæ•°æ®åº“ä¹‹é—´çš„é€šè®¯éƒ½"
-"å¿…é¡»åœ¨æŸä¸ªäº‹åŠ¡ä¸­è¿›è¡Œï¼Œä¸ç®¡ä½ æ˜¯åœ¨è¯»è¿˜æ˜¯åœ¨å†™æ•°æ®ã€‚å¯¹è¯»æ•°æ®è€Œè¨€ï¼Œåº”è¯¥é¿å… auto-"
-"commit è¡Œä¸ºï¼Œå› ä¸ºå¾ˆå¤šå°çš„äº‹åŠ¡æ¯”ä¸€ä¸ªæ¸…æ™°å®šä¹‰çš„å·¥ä½œå•å…ƒæ€§èƒ½å·®ã€‚åŽè€…ä¹Ÿæ›´å®¹æ˜“ç»´æŠ¤"
-"和扩展。 "
+msgid "Do not use the <emphasis>session-per-operation</emphasis> antipattern: do not open and close a <literal>Session</literal> for every simple database call in a single thread. The same is true for database transactions. Database calls in an application are made using a planned sequence; they are grouped into atomic units of work. This also means that auto-commit after every single SQL statement is useless in an application as this mode is intended for ad-hoc SQL console work. Hibernate disables, or expects the application server to disable, auto-commit mode immediately. Database transactions are never optional. All communication with a database has to occur inside a transaction. Auto-commit behavior for reading data should be avoided, as many small transactions are unlikely to perform better than one clearly defined unit of work. The latter is also more maintainable and extensible."
+msgstr "首先，别用 <emphasis>session-per-operation</emphasis> 这种反模式了，也就是说，在单个线程中， ä¸è¦å› ä¸ºä¸€æ¬¡ç®€å•çš„æ•°æ®åº“è°ƒç”¨ï¼Œå°±æ‰“å¼€å’Œå…³é—­ä¸€æ¬¡ <literal>Session</literal>！数据库事务也是如此。 应用程序中的数据库调用是按照计划好的次序，分组为原子的操作单元。（注意，这也意味着，应用程 序中，在单个的 SQL 语句发送之后，自动事务提交（auto-commit）模式失效了。这种模式专门为SQL控制台操作设计的。 Hibernate ç¦æ­¢ç«‹å³è‡ªåŠ¨äº‹åŠ¡æäº¤æ¨¡å¼ï¼Œæˆ–è€…æœŸæœ›åº”ç”¨æœåŠ¡å™¨ç¦æ­¢ç«‹å³è‡ªåŠ¨äº‹åŠ¡æäº¤æ¨¡å¼ã€‚ï¼‰æ•°æ®åº“äº‹åŠ¡ç»ä¸æ˜¯å¯æœ‰å¯æ— çš„ï¼Œä»»ä½•ä¸Žæ•°æ®åº“ä¹‹é—´çš„é€šè®¯éƒ½å¿…é¡»åœ¨æŸä¸ªäº‹åŠ¡ä¸­è¿›è¡Œï¼Œä¸ç®¡ä½ æ˜¯åœ¨è¯»è¿˜æ˜¯åœ¨å†™æ•°æ®ã€‚å¯¹è¯»æ•°æ®è€Œè¨€ï¼Œåº”è¯¥é¿å… auto-commit è¡Œä¸ºï¼Œå› ä¸ºå¾ˆå¤šå°çš„äº‹åŠ¡æ¯”ä¸€ä¸ªæ¸…æ™°å®šä¹‰çš„å·¥ä½œå•å…ƒæ€§èƒ½å·®ã€‚åŽè€…ä¹Ÿæ›´å®¹æ˜“ç»´æŠ¤å’Œæ‰©å±•ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The most common pattern in a multi-user client/server application is "
-"<emphasis>session-per-request</emphasis>. In this model, a request from the "
-"client is sent to the server, where the Hibernate persistence layer runs. A "
-"new Hibernate <literal>Session</literal> is opened, and all database "
-"operations are executed in this unit of work. On completion of the work, and "
-"once the response for the client has been prepared, the session is flushed "
-"and closed. Use a single database transaction to serve the clients request, "
-"starting and committing it when you open and close the <literal>Session</"
-"literal>. The relationship between the two is one-to-one and this model is a "
-"perfect fit for many applications."
-msgstr ""
-"在多用户的 client/server 应用程序中，最常用的模式是 <emphasis>每个请求一个会"
-"话（session-per-request）</emphasis>。 在这种模式下，来自客户端的请求被发送到"
-"服务器端（即 Hibernate 持久化层运行的地方），一个新的 Hibernate "
-"<literal>Session</literal> 被打开，并且执行这个操作单元中所有的数据库操作。一"
-"旦操作完成（同时对客户端的响应也准备就绪），session è¢«åŒæ­¥ï¼Œç„¶åŽå…³é—­ã€‚ä½ ä¹Ÿå¯"
-"以使用单 ä¸ªæ•°æ®åº“äº‹åŠ¡æ¥å¤„ç†å®¢æˆ·ç«¯è¯·æ±‚ï¼Œåœ¨ä½ æ‰“å¼€ <literal>Session</literal> 之"
-"åŽå¯åŠ¨äº‹åŠ¡ï¼Œåœ¨ä½ å…³é—­ <literal>Session</literal> 之前提交事务。会话和请求之间"
-"的关系是一对一的关系，这种模式对 于大多数应用程序来说是很棒的。 "
+msgid "The most common pattern in a multi-user client/server application is <emphasis>session-per-request</emphasis>. In this model, a request from the client is sent to the server, where the Hibernate persistence layer runs. A new Hibernate <literal>Session</literal> is opened, and all database operations are executed in this unit of work. On completion of the work, and once the response for the client has been prepared, the session is flushed and closed. Use a single database transaction to serve the clients request, starting and committing it when you open and close the <literal>Session</literal>. The relationship between the two is one-to-one and this model is a perfect fit for many applications."
+msgstr "在多用户的 client/server 应用程序中，最常用的模式是 <emphasis>每个请求一个会话（session-per-request）</emphasis>。 在这种模式下，来自客户端的请求被发送到服务器端（即 Hibernate 持久化层运行的地方），一个新的 Hibernate <literal>Session</literal> 被打开，并且执行这个操作单元中所有的数据库操作。一旦操作完成（同时对客户端的响应也准备就绪），session è¢«åŒæ­¥ï¼Œç„¶åŽå…³é—­ã€‚ä½ ä¹Ÿå¯ä»¥ä½¿ç”¨å• ä¸ªæ•°æ®åº“äº‹åŠ¡æ¥å¤„ç†å®¢æˆ·ç«¯è¯·æ±‚ï¼Œåœ¨ä½ æ‰“å¼€ <literal>Session</literal> ä¹‹åŽå¯åŠ¨äº‹åŠ¡ï¼Œåœ¨ä½ å…³é—­ <literal>Session</literal> 之前提交事务。会话和请求之间的关系是一对一的关系，这种模式对 于大多数应用程序来说是很棒的。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The challenge lies in the implementation. Hibernate provides built-in "
-"management of the \"current session\" to simplify this pattern. Start a "
-"transaction when a server request has to be processed, and end the "
-"transaction before the response is sent to the client. Common solutions are "
-"<literal>ServletFilter</literal>, AOP interceptor with a pointcut on the "
-"service methods, or a proxy/interception container. An EJB container is a "
-"standardized way to implement cross-cutting aspects such as transaction "
-"demarcation on EJB session beans, declaratively with CMT. If you use "
-"programmatic transaction demarcation, for ease of use and code portability "
-"use the Hibernate <literal>Transaction</literal> API shown later in this "
-"chapter."
-msgstr ""
-"实现才是真正的挑战。Hibernate 内置了对\"当前 session（current session）\" 的"
-"ç®¡ç†ï¼Œç”¨äºŽç®€åŒ–æ­¤æ¨¡å¼ã€‚ä½ è¦åšçš„ä¸€åˆ‡å°±æ˜¯åœ¨æœåŠ¡å™¨ç«¯è¦å¤„ç†è¯·æ±‚çš„æ—¶å€™ï¼Œå¼€å¯äº‹åŠ¡ï¼Œ"
-"åœ¨å“åº”å‘é€ç»™å®¢æˆ·ä¹‹å‰ç»“æŸäº‹åŠ¡ã€‚ä½ å¯ä»¥ç”¨ä»»ä½•æ–¹å¼æ¥å®Œæˆè¿™ä¸€æ“ä½œï¼Œé€šå¸¸çš„æ–¹æ¡ˆæœ‰ "
-"<literal>ServletFilter</literal>，在 service 方法中进行 pointcut 的 AOP 拦截"
-"器，或者 proxy/interception 容器。EJB 容器是实现横切诸如 EJB session bean 上"
-"的事务分界，用 CMT å¯¹äº‹åŠ¡è¿›è¡Œå£°æ˜Žç­‰æ–¹é¢çš„æ ‡å‡†æ‰‹æ®µã€‚å‡è‹¥ä½ å†³å®šä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡"
-"åˆ†ç•Œï¼Œè¯·å‚è€ƒæœ¬ç« åŽé¢è®²åˆ°çš„ Hibernate <literal>Transaction</literal> API，这对"
-"æ˜“ç”¨æ€§å’Œä»£ç å¯ç§»æ¤æ€§éƒ½æœ‰å¥½å¤„ã€‚ "
+msgid "The challenge lies in the implementation. Hibernate provides built-in management of the \"current session\" to simplify this pattern. Start a transaction when a server request has to be processed, and end the transaction before the response is sent to the client. Common solutions are <literal>ServletFilter</literal>, AOP interceptor with a pointcut on the service methods, or a proxy/interception container. An EJB container is a standardized way to implement cross-cutting aspects such as transaction demarcation on EJB session beans, declaratively with CMT. If you use programmatic transaction demarcation, for ease of use and code portability use the Hibernate <literal>Transaction</literal> API shown later in this chapter."
+msgstr "实现才是真正的挑战。Hibernate 内置了对\"当前 session（current session）\" çš„ç®¡ç†ï¼Œç”¨äºŽç®€åŒ–æ­¤æ¨¡å¼ã€‚ä½ è¦åšçš„ä¸€åˆ‡å°±æ˜¯åœ¨æœåŠ¡å™¨ç«¯è¦å¤„ç†è¯·æ±‚çš„æ—¶å€™ï¼Œå¼€å¯äº‹åŠ¡ï¼Œåœ¨å“åº”å‘é€ç»™å®¢æˆ·ä¹‹å‰ç»“æŸäº‹åŠ¡ã€‚ä½ å¯ä»¥ç”¨ä»»ä½•æ–¹å¼æ¥å®Œæˆè¿™ä¸€æ“ä½œï¼Œé€šå¸¸çš„æ–¹æ¡ˆæœ‰ <literal>ServletFilter</literal>，在 service 方法中进行 pointcut çš„ AOP 拦截器，或者 proxy/interception 容器。EJB 容器是实现横切诸如 EJB session bean 上的事务分界，用 CMT å¯¹äº‹åŠ¡è¿›è¡Œå£°æ˜Žç­‰æ–¹é¢çš„æ ‡å‡†æ‰‹æ®µã€‚å‡è‹¥ä½ å†³å®šä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡åˆ†ç•Œï¼Œè¯·å‚è€ƒæœ¬ç« åŽé¢è®²åˆ°çš„ Hibernate <literal>Transaction</literal> APIï¼Œè¿™å¯¹æ˜“ç”¨æ€§å’Œä»£ç å¯ç§»æ¤æ€§éƒ½æœ‰å¥½å¤„ã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Your application code can access a \"current session\" to process the "
-"request by calling <literal>sessionFactory.getCurrentSession()</literal>. "
-"You will always get a <literal>Session</literal> scoped to the current "
-"database transaction. This has to be configured for either resource-local or "
-"JTA environments, see <xref linkend=\"architecture-current-session\" />."
-msgstr ""
-"åœ¨ä»»ä½•æ—¶é—´ï¼Œä»»ä½•åœ°æ–¹ï¼Œä½ çš„åº”ç”¨ä»£ç å¯ä»¥é€šè¿‡ç®€å•çš„è°ƒç”¨<literal>sessionFactory."
-"getCurrentSession()</literal> 来访问\"当前 session\"ï¼Œç”¨äºŽå¤„ç†è¯·æ±‚ã€‚ä½ æ€»æ˜¯ä¼š"
-"得到当前数据库事务范围内的 <literal>Session</literal>。在使用本地资源或 JTA "
-"环境时，必须配置它，请参见 <xref linkend=\"architecture-current-session\"/>。"
+#, no-c-format
+msgid "Your application code can access a \"current session\" to process the request by calling <literal>sessionFactory.getCurrentSession()</literal>. You will always get a <literal>Session</literal> scoped to the current database transaction. This has to be configured for either resource-local or JTA environments, see <xref linkend=\"architecture-current-session\" />."
+msgstr "åœ¨ä»»ä½•æ—¶é—´ï¼Œä»»ä½•åœ°æ–¹ï¼Œä½ çš„åº”ç”¨ä»£ç å¯ä»¥é€šè¿‡ç®€å•çš„è°ƒç”¨<literal>sessionFactory.getCurrentSession()</literal> 来访问\"当前 session\"ï¼Œç”¨äºŽå¤„ç†è¯·æ±‚ã€‚ä½ æ€»æ˜¯ä¼šå¾—åˆ°å½“å‰æ•°æ®åº“äº‹åŠ¡èŒƒå›´å†…çš„ <literal>Session</literal>。在使用本地资源或 JTA 环境时，必须配置它，请参见 <xref linkend=\"architecture-current-session\"/>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can extend the scope of a <literal>Session</literal> and database "
-"transaction until the \"view has been rendered\". This is especially useful "
-"in servlet applications that utilize a separate rendering phase after the "
-"request has been processed. Extending the database transaction until view "
-"rendering, is achieved by implementing your own interceptor. However, this "
-"will be difficult if you rely on EJBs with container-managed transactions. A "
-"transaction will be completed when an EJB method returns, before rendering "
-"of any view can start. See the Hibernate website and forum for tips and "
-"examples relating to this <emphasis>Open Session in View</emphasis> pattern."
-msgstr ""
-"有时，将 <literal>Session</literal> 和数据库事务的边界延伸到\"展示层被渲染后"
-"\"会带来便利。有些 serlvet 应用程序在对请求进行处理后，有个单独的渲染期，这种"
-"å»¶ä¼¸å¯¹è¿™ç§ç¨‹åºç‰¹åˆ«æœ‰ç”¨ã€‚å‡è‹¥ä½ å®žçŽ°ä½ è‡ªå·±çš„æ‹¦æˆªå™¨ï¼ŒæŠŠäº‹åŠ¡è¾¹ç•Œå»¶ä¼¸åˆ°å±•ç¤ºå±‚æ¸²æŸ“"
-"ç»“æŸåŽéžå¸¸å®¹æ˜“ã€‚ç„¶è€Œï¼Œå‡è‹¥ä½ ä¾èµ–æœ‰å®¹å™¨ç®¡ç†äº‹åŠ¡çš„ EJBï¼Œè¿™å°±ä¸å¤ªå®¹æ˜“äº†ï¼Œå› ä¸ºäº‹"
-"务会在 EJB 方法返回后结束，而那是在任何展示层渲染开始之前。请访问  Hibernate "
-"ç½‘ç«™å’Œè®ºå›ï¼Œä½ å¯ä»¥æ‰¾åˆ° <emphasis>Open Session in View</emphasis> 这一模式的提"
-"示和示例。 "
+msgid "You can extend the scope of a <literal>Session</literal> and database transaction until the \"view has been rendered\". This is especially useful in servlet applications that utilize a separate rendering phase after the request has been processed. Extending the database transaction until view rendering, is achieved by implementing your own interceptor. However, this will be difficult if you rely on EJBs with container-managed transactions. A transaction will be completed when an EJB method returns, before rendering of any view can start. See the Hibernate website and forum for tips and examples relating to this <emphasis>Open Session in View</emphasis> pattern."
+msgstr "有时，将 <literal>Session</literal> 和数据库事务的边界延伸到\"展示层被渲染后\"会带来便利。有些 serlvet åº”ç”¨ç¨‹åºåœ¨å¯¹è¯·æ±‚è¿›è¡Œå¤„ç†åŽï¼Œæœ‰ä¸ªå•ç‹¬çš„æ¸²æŸ“æœŸï¼Œè¿™ç§å»¶ä¼¸å¯¹è¿™ç§ç¨‹åºç‰¹åˆ«æœ‰ç”¨ã€‚å‡è‹¥ä½ å®žçŽ°ä½ è‡ªå·±çš„æ‹¦æˆªå™¨ï¼ŒæŠŠäº‹åŠ¡è¾¹ç•Œå»¶ä¼¸åˆ°å±•ç¤ºå±‚æ¸²æŸ“ç»“æŸåŽéžå¸¸å®¹æ˜“ã€‚ç„¶è€Œï¼Œå‡è‹¥ä½ ä¾èµ–æœ‰å®¹å™¨ç®¡ç†äº‹åŠ¡çš„ EJBï¼Œè¿™å°±ä¸å¤ªå®¹æ˜“äº†ï¼Œå› ä¸ºäº‹åŠ¡ä¼šåœ¨ EJB 方法返回后结束，而那是在任何展示层渲染开始之前。请访问  Hibernate ç½‘ç«™å’Œè®ºå›ï¼Œä½ å¯ä»¥æ‰¾åˆ° <emphasis>Open Session in View</emphasis> 这一模式的提示和示例。 "
 
 #. Tag: title
 #, no-c-format
@@ -275,141 +106,53 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The session-per-request pattern is not the only way of designing units of "
-"work. Many business processes require a whole series of interactions with "
-"the user that are interleaved with database accesses. In web and enterprise "
-"applications, it is not acceptable for a database transaction to span a user "
-"interaction. Consider the following example:"
-msgstr ""
-"session-per-request 模式不仅仅是一个可以用来设计操作单元的有用概念。很多业务"
-"处理都需 要一系列完整的与用户之间的交互，而这些用户是指对数据库有交叉访问的用"
-"户。在基于 web çš„åº”ç”¨å’Œä¼ä¸šåº”ç”¨ä¸­ï¼Œè·¨ç”¨æˆ·äº¤äº’çš„æ•°æ®åº“äº‹åŠ¡æ˜¯æ— æ³•æŽ¥å—çš„ã€‚è€ƒè™‘ä¸‹"
-"面的例子： "
+msgid "The session-per-request pattern is not the only way of designing units of work. Many business processes require a whole series of interactions with the user that are interleaved with database accesses. In web and enterprise applications, it is not acceptable for a database transaction to span a user interaction. Consider the following example:"
+msgstr "session-per-request 模式不仅仅是一个可以用来设计操作单元的有用概念。很多业务处理都需 要一系列完整的与用户之间的交互，而这些用户是指对数据库有交叉访问的用户。在基于 web çš„åº”ç”¨å’Œä¼ä¸šåº”ç”¨ä¸­ï¼Œè·¨ç”¨æˆ·äº¤äº’çš„æ•°æ®åº“äº‹åŠ¡æ˜¯æ— æ³•æŽ¥å—çš„ã€‚è€ƒè™‘ä¸‹é¢çš„ä¾‹å­ï¼š "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The first screen of a dialog opens. The data seen by the user has been "
-"loaded in a particular <literal>Session</literal> and database transaction. "
-"The user is free to modify the objects."
-msgstr ""
-"在界面的第一屏，打开对话框，用户所看到的数据是被一个特定的 <literal>Session</"
-"literal> 和数据 库事务载入（load）的。用户可以随意修改对话框中的数据对象。 "
+msgid "The first screen of a dialog opens. The data seen by the user has been loaded in a particular <literal>Session</literal> and database transaction. The user is free to modify the objects."
+msgstr "在界面的第一屏，打开对话框，用户所看到的数据是被一个特定的 <literal>Session</literal> 和数据 库事务载入（load）的。用户可以随意修改对话框中的数据对象。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The user clicks \"Save\" after 5 minutes and expects their modifications to "
-"be made persistent. The user also expects that they were the only person "
-"editing this information and that no conflicting modification has occurred."
-msgstr ""
-"5 分钟后，用户点击“保存”，期望所做出的修改被持久化；同时他也期望自己是唯一修"
-"改这个信息的人，不会出现修改冲突。 "
+msgid "The user clicks \"Save\" after 5 minutes and expects their modifications to be made persistent. The user also expects that they were the only person editing this information and that no conflicting modification has occurred."
+msgstr "5 分钟后，用户点击“保存”，期望所做出的修改被持久化；同时他也期望自己是唯一修改这个信息的人，不会出现修改冲突。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"From the point of view of the user, we call this unit of work a long-running "
-"<emphasis>conversation</emphasis> or <emphasis>application transaction</"
-"emphasis>. There are many ways to implement this in your application."
-msgstr ""
-"从用户的角度来看，我们把这个操作单元称为长时间运行的<emphasis>对话</emphasis>"
-"（conversation），或者<emphasis>应用事务</emphasis>（application "
-"transactionï¼‰ã€‚åœ¨ä½ çš„åº”ç”¨ç¨‹åºä¸­ï¼Œå¯ä»¥æœ‰å¾ˆå¤šç§æ–¹æ³•æ¥å®žçŽ°å®ƒã€‚"
+msgid "From the point of view of the user, we call this unit of work a long-running <emphasis>conversation</emphasis> or <emphasis>application transaction</emphasis>. There are many ways to implement this in your application."
+msgstr "从用户的角度来看，我们把这个操作单元称为长时间运行的<emphasis>对话</emphasis>（conversation），或者<emphasis>应用事务</emphasis>（application transactionï¼‰ã€‚åœ¨ä½ çš„åº”ç”¨ç¨‹åºä¸­ï¼Œå¯ä»¥æœ‰å¾ˆå¤šç§æ–¹æ³•æ¥å®žçŽ°å®ƒã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A first naive implementation might keep the <literal>Session</literal> and "
-"database transaction open during user think time, with locks held in the "
-"database to prevent concurrent modification and to guarantee isolation and "
-"atomicity. This is an anti-pattern, since lock contention would not allow "
-"the application to scale with the number of concurrent users."
-msgstr ""
-"头一个幼稚的做法是，在用户思考的过程中，保持 <literal>Session</literal> 和数"
-"据库事务是打开的，保持数据库锁定，以阻止并发修改，从而保证数据库事务隔离级别"
-"å’ŒåŽŸå­æ“ä½œã€‚è¿™ç§æ–¹å¼å½“ç„¶æ˜¯ä¸€ä¸ªåæ¨¡å¼ï¼Œå› ä¸ºé”äº‰ç”¨ä¼šå¯¼è‡´åº”ç”¨ç¨‹åºæ— æ³•æ‰©å±•å¹¶å‘ç”¨"
-"户的数目。 "
+msgid "A first naive implementation might keep the <literal>Session</literal> and database transaction open during user think time, with locks held in the database to prevent concurrent modification and to guarantee isolation and atomicity. This is an anti-pattern, since lock contention would not allow the application to scale with the number of concurrent users."
+msgstr "头一个幼稚的做法是，在用户思考的过程中，保持 <literal>Session</literal> å’Œæ•°æ®åº“äº‹åŠ¡æ˜¯æ‰“å¼€çš„ï¼Œä¿æŒæ•°æ®åº“é”å®šï¼Œä»¥é˜»æ­¢å¹¶å‘ä¿®æ”¹ï¼Œä»Žè€Œä¿è¯æ•°æ®åº“äº‹åŠ¡éš”ç¦»çº§åˆ«å’ŒåŽŸå­æ“ä½œã€‚è¿™ç§æ–¹å¼å½“ç„¶æ˜¯ä¸€ä¸ªåæ¨¡å¼ï¼Œå› ä¸ºé”äº‰ç”¨ä¼šå¯¼è‡´åº”ç”¨ç¨‹åºæ— æ³•æ‰©å±•å¹¶å‘ç”¨æˆ·çš„æ•°ç›®ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You have to use several database transactions to implement the conversation. "
-"In this case, maintaining isolation of business processes becomes the "
-"partial responsibility of the application tier. A single conversation "
-"usually spans several database transactions. It will be atomic if only one "
-"of these database transactions (the last one) stores the updated data. All "
-"others simply read data (for example, in a wizard-style dialog spanning "
-"several request/response cycles). This is easier to implement than it might "
-"sound, especially if you utilize some of Hibernate's features:"
-msgstr ""
-"很明显，我们必须使用多个数据库事务来实现这个对话。在这个例子中，维护业务处理"
-"的 事务隔离变成了应用程序层的部分责任。一个对话通常跨越多个数据库事务。如果仅"
-"仅只有一个数据库事务（最后的那个事务）保存更新过的数据，而所有其他事务只是单"
-"纯的读取数据（例如在一个跨越多个请求/å“åº”å‘¨æœŸçš„å‘å¯¼é£Žæ ¼çš„å¯¹è¯æ¡†ä¸­ï¼‰ï¼Œé‚£ä¹ˆåº”ç”¨"
-"ç¨‹åºäº‹åŠ¡å°†ä¿è¯å…¶åŽŸå­æ€§ã€‚è¿™ç§æ–¹å¼æ¯”å¬èµ·æ¥è¿˜è¦å®¹æ˜“å®žçŽ°ï¼Œç‰¹åˆ«æ˜¯å½“ä½ ä½¿ç”¨äº† "
-"Hibernate 的下述特性的时候： "
+msgid "You have to use several database transactions to implement the conversation. In this case, maintaining isolation of business processes becomes the partial responsibility of the application tier. A single conversation usually spans several database transactions. It will be atomic if only one of these database transactions (the last one) stores the updated data. All others simply read data (for example, in a wizard-style dialog spanning several request/response cycles). This is easier to implement than it might sound, especially if you utilize some of Hibernate's features:"
+msgstr "很明显，我们必须使用多个数据库事务来实现这个对话。在这个例子中，维护业务处理的 事务隔离变成了应用程序层的部分责任。一个对话通常跨越多个数据库事务。如果仅仅只有一个数据库事务（最后的那个事务）保存更新过的数据，而所有其他事务只是单纯的读取数据（例如在一个跨越多个请求/å“åº”å‘¨æœŸçš„å‘å¯¼é£Žæ ¼çš„å¯¹è¯æ¡†ä¸­ï¼‰ï¼Œé‚£ä¹ˆåº”ç”¨ç¨‹åºäº‹åŠ¡å°†ä¿è¯å…¶åŽŸå­æ€§ã€‚è¿™ç§æ–¹å¼æ¯”å¬èµ·æ¥è¿˜è¦å®¹æ˜“å®žçŽ°ï¼Œç‰¹åˆ«æ˜¯å½“ä½ ä½¿ç”¨äº† Hibernate 的下述特性的时候： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Automatic Versioning</emphasis>: Hibernate can perform automatic "
-"optimistic concurrency control for you. It can automatically detect if a "
-"concurrent modification occurred during user think time. Check for this at "
-"the end of the conversation."
-msgstr ""
-"<emphasis>自动版本化</emphasis>：Hibernate 能够自动进行乐观并发控制，如果在用"
-"户思考的过程中发生并发修改，Hibernate 能够自动检测到。一般我们只在对话结束时"
-"才检查。"
+msgid "<emphasis>Automatic Versioning</emphasis>: Hibernate can perform automatic optimistic concurrency control for you. It can automatically detect if a concurrent modification occurred during user think time. Check for this at the end of the conversation."
+msgstr "<emphasis>自动版本化</emphasis>：Hibernate 能够自动进行乐观并发控制，如果在用户思考的过程中发生并发修改，Hibernate 能够自动检测到。一般我们只在对话结束时才检查。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Detached Objects</emphasis>: if you decide to use the "
-"<emphasis>session-per-request</emphasis> pattern, all loaded instances will "
-"be in the detached state during user think time. Hibernate allows you to "
-"reattach the objects and persist the modifications. The pattern is called "
-"<emphasis>session-per-request-with-detached-objects</emphasis>. Automatic "
-"versioning is used to isolate concurrent modifications."
-msgstr ""
-"<emphasis>脱管对象</emphasis>（Detached Objectsï¼‰ï¼šå¦‚æžœä½ å†³å®šé‡‡ç”¨å‰é¢å·²ç»è®¨è®º"
-"过的  <emphasis>session-per-request</emphasis> 模式，所有载入的实例在用户思考"
-"的过程中都处于与 Session 脱离的状态。Hibernate å…è®¸ä½ æŠŠä¸Ž Session 脱离的对象"
-"重新关联到 Session 上，并且对修改进行持久化，这种模式被称为 "
-"<emphasis>session-per-request-with-detached-objects</emphasis>。自动版本化被"
-"用来隔离并发修改。"
+msgid "<emphasis>Detached Objects</emphasis>: if you decide to use the <emphasis>session-per-request</emphasis> pattern, all loaded instances will be in the detached state during user think time. Hibernate allows you to reattach the objects and persist the modifications. The pattern is called <emphasis>session-per-request-with-detached-objects</emphasis>. Automatic versioning is used to isolate concurrent modifications."
+msgstr "<emphasis>脱管对象</emphasis>（Detached Objectsï¼‰ï¼šå¦‚æžœä½ å†³å®šé‡‡ç”¨å‰é¢å·²ç»è®¨è®ºè¿‡çš„  <emphasis>session-per-request</emphasis> 模式，所有载入的实例在用户思考的过程中都处于与 Session 脱离的状态。Hibernate å…è®¸ä½ æŠŠä¸Ž Session 脱离的对象重新关联到 Session 上，并且对修改进行持久化，这种模式被称为 <emphasis>session-per-request-with-detached-objects</emphasis>。自动版本化被用来隔离并发修改。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<emphasis>Extended (or Long) Session</emphasis>: the Hibernate "
-"<literal>Session</literal> can be disconnected from the underlying JDBC "
-"connection after the database transaction has been committed and reconnected "
-"when a new client request occurs. This pattern is known as <emphasis>session-"
-"per-conversation</emphasis> and makes even reattachment unnecessary. "
-"Automatic versioning is used to isolate concurrent modifications and the "
-"<literal>Session</literal> will not be allowed to be flushed automatically, "
-"but explicitly."
-msgstr ""
-"<emphasis>Extended (or Long) Session</emphasis>：Hibernate 的 "
-"<literal>Session</literal> 可以在数据库事务提交之后和底层的 JDBC 连接断开，当"
-"一个新的客户端请求到来的时候，它又重新连接上底层的 JDBC 连接。这种模式被称之"
-"为<emphasis>session-per-conversation</emphasis>，这种情况可 èƒ½ä¼šé€ æˆä¸å¿…è¦çš„ "
-"Session 和 JDBC 连接的重新关联。自动版本化被用来隔离并发修改，"
-"<literal>Session</literal> 通常不允许自动 flush，而是显性地 flush。 "
+msgid "<emphasis>Extended (or Long) Session</emphasis>: the Hibernate <literal>Session</literal> can be disconnected from the underlying JDBC connection after the database transaction has been committed and reconnected when a new client request occurs. This pattern is known as <emphasis>session-per-conversation</emphasis> and makes even reattachment unnecessary. Automatic versioning is used to isolate concurrent modifications and the <literal>Session</literal> will not be allowed to be flushed automatically, but explicitly."
+msgstr "<emphasis>Extended (or Long) Session</emphasis>：Hibernate çš„ <literal>Session</literal> 可以在数据库事务提交之后和底层的 JDBC 连接断开，当一个新的客户端请求到来的时候，它又重新连接上底层的 JDBC 连接。这种模式被称之为<emphasis>session-per-conversation</emphasis>，这种情况可 èƒ½ä¼šé€ æˆä¸å¿…è¦çš„ Session å’Œ JDBC 连接的重新关联。自动版本化被用来隔离并发修改，<literal>Session</literal> 通常不允许自动 flush，而是显性地 flush。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Both <emphasis>session-per-request-with-detached-objects</emphasis> and "
-"<emphasis>session-per-conversation</emphasis> have advantages and "
-"disadvantages. These disadvantages are discussed later in this chapter in "
-"the context of optimistic concurrency control."
-msgstr ""
-"<emphasis>session-per-request-with-detached-objects</emphasis> 和  "
-"<emphasis>session-per-conversation</emphasis> å„æœ‰ä¼˜ç¼ºç‚¹ï¼Œæˆ‘ä»¬åœ¨æœ¬ç« åŽé¢ä¹è§‚"
-"并发控制那部分再进行讨论。 "
+msgid "Both <emphasis>session-per-request-with-detached-objects</emphasis> and <emphasis>session-per-conversation</emphasis> have advantages and disadvantages. These disadvantages are discussed later in this chapter in the context of optimistic concurrency control."
+msgstr "<emphasis>session-per-request-with-detached-objects</emphasis> å’Œ  <emphasis>session-per-conversation</emphasis> å„æœ‰ä¼˜ç¼ºç‚¹ï¼Œæˆ‘ä»¬åœ¨æœ¬ç« åŽé¢ä¹è§‚å¹¶å‘æŽ§åˆ¶é‚£éƒ¨åˆ†å†è¿›è¡Œè®¨è®ºã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -418,15 +161,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An application can concurrently access the same persistent state in two "
-"different <literal>Session</literal>s. However, an instance of a persistent "
-"class is never shared between two <literal>Session</literal> instances. It "
-"is for this reason that there are two different notions of identity:"
-msgstr ""
-"应用程序可能在两个不同的 <literal>Session</literal> 中并发访问同一持久化状"
-"æ€ï¼Œä½†æ˜¯ï¼Œä¸€ä¸ªæŒä¹…åŒ–ç±»çš„å®žä¾‹æ— æ³•åœ¨ä¸¤ä¸ª <literal>Session</literal> ä¸­å…±äº«ã€‚å› "
-"æ­¤æœ‰ä¸¤ç§ä¸åŒçš„æ ‡è¯†è¯­ä¹‰ï¼š "
+msgid "An application can concurrently access the same persistent state in two different <literal>Session</literal>s. However, an instance of a persistent class is never shared between two <literal>Session</literal> instances. It is for this reason that there are two different notions of identity:"
+msgstr "应用程序可能在两个不同的 <literal>Session</literal> ä¸­å¹¶å‘è®¿é—®åŒä¸€æŒä¹…åŒ–çŠ¶æ€ï¼Œä½†æ˜¯ï¼Œä¸€ä¸ªæŒä¹…åŒ–ç±»çš„å®žä¾‹æ— æ³•åœ¨ä¸¤ä¸ª <literal>Session</literal> ä¸­å…±äº«ã€‚å› æ­¤æœ‰ä¸¤ç§ä¸åŒçš„æ ‡è¯†è¯­ä¹‰ï¼š "
 
 #. Tag: term
 #, no-c-format
@@ -434,9 +170,9 @@
 msgstr "æ•°æ®åº“æ ‡è¯†"
 
 #. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
 msgid "<literal>foo.getId().equals( bar.getId() )</literal>"
-msgstr "foo.getId().equals( bar.getId() )"
+msgstr "<literal>foo.getId().equals( bar.getId() )</literal>"
 
 #. Tag: term
 #, no-c-format
@@ -446,83 +182,22 @@
 #. Tag: para
 #, no-c-format
 msgid "<literal>foo==bar</literal>"
-msgstr ""
+msgstr "<literal>foo==bar</literal>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"For objects attached to a <emphasis>particular</emphasis> <literal>Session</"
-"literal> (i.e., in the scope of a <literal>Session</literal>), the two "
-"notions are equivalent and JVM identity for database identity is guaranteed "
-"by Hibernate. While the application might concurrently access the \"same"
-"\" (persistent identity) business object in two different sessions, the two "
-"instances will actually be \"different\" (JVM identity). Conflicts are "
-"resolved using an optimistic approach and automatic versioning at flush/"
-"commit time."
-msgstr ""
-"对于那些关联到 <emphasis>特定</emphasis> <literal>Session</literal>（也就是在"
-"单个 <literal>Session</literal> çš„èŒƒå›´å†…ï¼‰ä¸Šçš„å¯¹è±¡æ¥è¯´ï¼Œè¿™ä¸¤ç§æ ‡è¯†çš„è¯­ä¹‰æ˜¯ç­‰"
-"ä»·çš„ï¼Œä¸Žæ•°æ®åº“æ ‡è¯†å¯¹åº”çš„ JVM æ ‡è¯†æ˜¯ç”± Hibernate 来保证的。不过，当应用程序在"
-"两个不同的 session ä¸­å¹¶å‘è®¿é—®å…·æœ‰åŒä¸€æŒä¹…åŒ–æ ‡è¯†çš„ä¸šåŠ¡å¯¹è±¡å®žä¾‹çš„æ—¶å€™ï¼Œè¿™ä¸ªä¸šåŠ¡"
-"对象的两个实例事实上是不相同的（从 JVM 识别来看）。这种冲突可以通过在同步和提"
-"交的时候使用自动版本化和乐观锁定方法来解决。 "
+msgid "For objects attached to a <emphasis>particular</emphasis> <literal>Session</literal> (i.e., in the scope of a <literal>Session</literal>), the two notions are equivalent and JVM identity for database identity is guaranteed by Hibernate. While the application might concurrently access the \"same\" (persistent identity) business object in two different sessions, the two instances will actually be \"different\" (JVM identity). Conflicts are resolved using an optimistic approach and automatic versioning at flush/commit time."
+msgstr "对于那些关联到 <emphasis>特定</emphasis> <literal>Session</literal>（也就是在单个 <literal>Session</literal> çš„èŒƒå›´å†…ï¼‰ä¸Šçš„å¯¹è±¡æ¥è¯´ï¼Œè¿™ä¸¤ç§æ ‡è¯†çš„è¯­ä¹‰æ˜¯ç­‰ä»·çš„ï¼Œä¸Žæ•°æ®åº“æ ‡è¯†å¯¹åº”çš„ JVM æ ‡è¯†æ˜¯ç”± Hibernate 来保证的。不过，当应用程序在两个不同的 session ä¸­å¹¶å‘è®¿é—®å…·æœ‰åŒä¸€æŒä¹…åŒ–æ ‡è¯†çš„ä¸šåŠ¡å¯¹è±¡å®žä¾‹çš„æ—¶å€™ï¼Œè¿™ä¸ªä¸šåŠ¡å¯¹è±¡çš„ä¸¤ä¸ªå®žä¾‹äº‹å®žä¸Šæ˜¯ä¸ç›¸åŒçš„ï¼ˆä»Ž JVM 识别来看）。这种冲突可以通过在同步和提交的时候使用自动版本化和乐观锁定方法来解决。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This approach leaves Hibernate and the database to worry about concurrency. "
-"It also provides the best scalability, since guaranteeing identity in single-"
-"threaded units of work means that it does not need expensive locking or "
-"other means of synchronization. The application does not need to synchronize "
-"on any business object, as long as it maintains a single thread per "
-"<literal>Session</literal>. Within a <literal>Session</literal> the "
-"application can safely use <literal>==</literal> to compare objects."
-msgstr ""
-"这种方式把关于并发的头疼问题留给了 Hibernate 和数据库；由于在单个线程内，操作"
-"单元中的对象识别不 éœ€è¦ä»£ä»·æ˜‚è´µçš„é”å®šæˆ–å…¶ä»–æ„ä¹‰ä¸Šçš„åŒæ­¥ï¼Œå› æ­¤å®ƒåŒæ—¶å¯ä»¥æä¾›æœ€"
-"好的可伸缩性。只要在单个线程只持有一个 <literal>Session</literal>，应用程序就"
-"不需要同步任何业务对象。在 <literal>Session</literal> 的范围内，应用程序可以"
-"放心的使用 <literal>==</literal> 进行对象比较。 "
+msgid "This approach leaves Hibernate and the database to worry about concurrency. It also provides the best scalability, since guaranteeing identity in single-threaded units of work means that it does not need expensive locking or other means of synchronization. The application does not need to synchronize on any business object, as long as it maintains a single thread per <literal>Session</literal>. Within a <literal>Session</literal> the application can safely use <literal>==</literal> to compare objects."
+msgstr "这种方式把关于并发的头疼问题留给了 Hibernate 和数据库；由于在单个线程内，操作单元中的对象识别不 éœ€è¦ä»£ä»·æ˜‚è´µçš„é”å®šæˆ–å…¶ä»–æ„ä¹‰ä¸Šçš„åŒæ­¥ï¼Œå› æ­¤å®ƒåŒæ—¶å¯ä»¥æä¾›æœ€å¥½çš„å¯ä¼¸ç¼©æ€§ã€‚åªè¦åœ¨å•ä¸ªçº¿ç¨‹åªæŒæœ‰ä¸€ä¸ª <literal>Session</literal>，应用程序就不需要同步任何业务对象。在 <literal>Session</literal> 的范围内，应用程序可以放心的使用 <literal>==</literal> 进行对象比较。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"However, an application that uses <literal>==</literal> outside of a "
-"<literal>Session</literal> might produce unexpected results. This might "
-"occur even in some unexpected places. For example, if you put two detached "
-"instances into the same <literal>Set</literal>, both might have the same "
-"database identity (i.e., they represent the same row). JVM identity, "
-"however, is by definition not guaranteed for instances in a detached state. "
-"The developer has to override the <literal>equals()</literal> and "
-"<literal>hashCode()</literal> methods in persistent classes and implement "
-"their own notion of object equality. There is one caveat: never use the "
-"database identifier to implement equality. Use a business key that is a "
-"combination of unique, usually immutable, attributes. The database "
-"identifier will change if a transient object is made persistent. If the "
-"transient instance (usually together with detached instances) is held in a "
-"<literal>Set</literal>, changing the hashcode breaks the contract of the "
-"<literal>Set</literal>. Attributes for business keys do not have to be as "
-"stable as database primary keys; you only have to guarantee stability as "
-"long as the objects are in the same <literal>Set</literal>. See the "
-"Hibernate website for a more thorough discussion of this issue. Please note "
-"that this is not a Hibernate issue, but simply how Java object identity and "
-"equality has to be implemented."
-msgstr ""
-"不过，应用程序在 <literal>Session</literal> 的外面使用 <literal>==</literal> "
-"进行对象比较可能会 å¯¼è‡´æ— æ³•é¢„æœŸçš„ç»“æžœã€‚åœ¨ä¸€äº›æ— æ³•é¢„æ–™çš„åœºåˆï¼Œä¾‹å¦‚ï¼Œå¦‚æžœä½ æŠŠä¸¤"
-"个脱管对象实例放进同一个  <literal>Set</literal> 的时候，就可能发生。这两个对"
-"è±¡å®žä¾‹å¯èƒ½æœ‰åŒä¸€ä¸ªæ•°æ®åº“æ ‡è¯†ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œ 他们代表了表的同一行数据），从 JVM "
-"æ ‡è¯†çš„å®šä¹‰ä¸Šæ¥è¯´ï¼Œå¯¹è„±ç®¡çš„å¯¹è±¡è€Œè¨€ï¼ŒHibernate æ— æ³•ä¿è¯ä»–ä»¬ çš„çš„ JVM æ ‡è¯†ä¸€"
-"致。开发人员必须覆盖持久化类的 <literal>equals()</literal> 方法和  "
-"<literal>hashCode()</literal> 方法，从而实现自定义的对象相等语义。警告：不要"
-"ä½¿ç”¨æ•°æ®åº“æ ‡è¯†æ¥å®žçŽ°å¯¹è±¡ç›¸ç­‰ï¼Œåº”è¯¥ä½¿ç”¨ä¸šåŠ¡é”®å€¼ï¼Œç”±å”¯ä¸€çš„ï¼Œé€šå¸¸ä¸å˜çš„å±žæ€§ç»„"
-"æˆã€‚å½“ä¸€ä¸ªçž¬æ—¶å¯¹è±¡è¢«æŒä¹…åŒ–çš„æ—¶å€™ï¼Œå®ƒçš„æ•°æ®åº“æ ‡è¯†ä¼šå‘ç”Ÿæ”¹å˜ã€‚å¦‚æžœä¸€ä¸ªçž¬æ—¶å¯¹è±¡"
-"（通常也包括脱管对象实例）被放入一个 <literal>Set</literal>，改变它的 "
-"hashcode 会导致与这个 <literal>Set</literal> 的关系中断。虽 然业务键值的属性"
-"ä¸è±¡æ•°æ®åº“ä¸»é”®é‚£æ ·ç¨³å®šä¸å˜ï¼Œä½†æ˜¯ä½ åªéœ€è¦ä¿è¯åœ¨åŒä¸€ä¸ª <literal>Set</literal> "
-"中的对象属性的稳定性就足够了。请到 Hibernate 网站去寻求这个问题更多的详细的讨"
-"论。请注意，这不是一个有关 Hibernate 的问题，而仅仅是一个关于 Java å¯¹è±¡æ ‡è¯†å’Œ"
-"判等行为如何实现的问题。 "
+msgid "However, an application that uses <literal>==</literal> outside of a <literal>Session</literal> might produce unexpected results. This might occur even in some unexpected places. For example, if you put two detached instances into the same <literal>Set</literal>, both might have the same database identity (i.e., they represent the same row). JVM identity, however, is by definition not guaranteed for instances in a detached state. The developer has to override the <literal>equals()</literal> and <literal>hashCode()</literal> methods in persistent classes and implement their own notion of object equality. There is one caveat: never use the database identifier to implement equality. Use a business key that is a combination of unique, usually immutable, attributes. The database identifier will change if a transient object is made persistent. If the transient instance (usually together with detached instances) is held in a <literal>Set</literal>, changing the hashcode bre!
 aks the contract of the <literal>Set</literal>. Attributes for business keys do not have to be as stable as database primary keys; you only have to guarantee stability as long as the objects are in the same <literal>Set</literal>. See the Hibernate website for a more thorough discussion of this issue. Please note that this is not a Hibernate issue, but simply how Java object identity and equality has to be implemented."
+msgstr "不过，应用程序在 <literal>Session</literal> 的外面使用 <literal>==</literal> 进行对象比较可能会 å¯¼è‡´æ— æ³•é¢„æœŸçš„ç»“æžœã€‚åœ¨ä¸€äº›æ— æ³•é¢„æ–™çš„åœºåˆï¼Œä¾‹å¦‚ï¼Œå¦‚æžœä½ æŠŠä¸¤ä¸ªè„±ç®¡å¯¹è±¡å®žä¾‹æ”¾è¿›åŒä¸€ä¸ª  <literal>Set</literal> çš„æ—¶å€™ï¼Œå°±å¯èƒ½å‘ç”Ÿã€‚è¿™ä¸¤ä¸ªå¯¹è±¡å®žä¾‹å¯èƒ½æœ‰åŒä¸€ä¸ªæ•°æ®åº“æ ‡è¯†ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œ 他们代表了表的同一行数据），从 JVM æ ‡è¯†çš„å®šä¹‰ä¸Šæ¥è¯´ï¼Œå¯¹è„±ç®¡çš„å¯¹è±¡è€Œè¨€ï¼ŒHibernate æ— æ³•ä¿è¯ä»–ä»¬ çš„çš„ JVM æ ‡è¯†ä¸€è‡´ã€‚å¼€å‘äººå‘˜å¿…é¡»è¦†ç›–æŒä¹…åŒ–ç±»çš„ <literal>equals()</literal> 方法和  <literal>hashCode()</literal> æ–¹æ³•ï¼Œä»Žè€Œå®žçŽ°è‡ªå®šä¹‰çš„å¯¹è±¡ç›¸ç­‰è¯­ä¹‰ã€‚è­¦å‘Šï¼šä¸è¦ä½¿ç”¨æ•°æ®åº“æ ‡è¯†æ¥å®žçŽ°å¯¹è±¡ç›¸ç­‰ï¼Œåº”è¯¥ä½¿ç”¨ä¸šåŠ¡é”®å€¼ï¼Œç”±å”¯ä¸€çš„ï¼Œé€šå¸¸ä¸å˜çš„å±žæ€§ç»„æˆã€‚å½“ä¸€ä¸ªçž¬æ—¶å¯¹è±¡è¢«æŒä¹…åŒ–çš„æ—¶å€™ï¼Œå®ƒçš„æ•°æ®åº“æ ‡è¯†ä¼šå‘ç”Ÿæ”¹å˜ã€‚å¦‚æžœä¸€ä¸ªçž¬æ—¶å¯¹è±¡ï¼ˆé€šå¸¸ä¹ŸåŒ…æ‹¬è„±ç®¡å¯¹è±¡å®žä¾‹ï¼‰è¢«æ”¾å…¥ä!
 ¸€ä¸ª <literal>Set</literal>，改变它的 hashcode 会导致与这个 <literal>Set</literal> 的关系中断。虽 ç„¶ä¸šåŠ¡é”®å€¼çš„å±žæ€§ä¸è±¡æ•°æ®åº“ä¸»é”®é‚£æ ·ç¨³å®šä¸å˜ï¼Œä½†æ˜¯ä½ åªéœ€è¦ä¿è¯åœ¨åŒä¸€ä¸ª <literal>Set</literal> 中的对象属性的稳定性就足够了。请到 Hibernate 网站去寻求这个问题更多的详细的讨论。请注意，这不是一个有关 Hibernate 的问题，而仅仅是一个关于 Java å¯¹è±¡æ ‡è¯†å’Œåˆ¤ç­‰è¡Œä¸ºå¦‚ä½•å®žçŽ°çš„é—®é¢˜ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -531,80 +206,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Do not use the anti-patterns <emphasis>session-per-user-session</emphasis> "
-"or <emphasis>session-per-application</emphasis> (there are, however, rare "
-"exceptions to this rule). Some of the following issues might also arise "
-"within the recommended patterns, so ensure that you understand the "
-"implications before making a design decision:"
-msgstr ""
-"决不要使用反模式 <emphasis>session-per-user-session</emphasis> 或者 "
-"<emphasis> session-per-application</emphasis>ï¼ˆå½“ç„¶ï¼Œè¿™ä¸ªè§„å®šå‡ ä¹Žæ²¡æœ‰ä¾‹å¤–ï¼‰ã€‚"
-"è¯·æ³¨æ„ï¼Œä¸‹è¿°ä¸€äº›é—®é¢˜å¯èƒ½ä¹Ÿä¼šå‡ºçŽ°åœ¨æˆ‘ä»¬æŽ¨èçš„æ¨¡å¼ä¸­ï¼Œåœ¨ä½ ä½œå‡ºæŸä¸ªè®¾è®¡å†³å®šä¹‹"
-"前，请务必理解该模式的应用前提。 "
+msgid "Do not use the anti-patterns <emphasis>session-per-user-session</emphasis> or <emphasis>session-per-application</emphasis> (there are, however, rare exceptions to this rule). Some of the following issues might also arise within the recommended patterns, so ensure that you understand the implications before making a design decision:"
+msgstr "决不要使用反模式 <emphasis>session-per-user-session</emphasis> 或者 <emphasis> session-per-application</emphasis>ï¼ˆå½“ç„¶ï¼Œè¿™ä¸ªè§„å®šå‡ ä¹Žæ²¡æœ‰ä¾‹å¤–ï¼‰ã€‚è¯·æ³¨æ„ï¼Œä¸‹è¿°ä¸€äº›é—®é¢˜å¯èƒ½ä¹Ÿä¼šå‡ºçŽ°åœ¨æˆ‘ä»¬æŽ¨èçš„æ¨¡å¼ä¸­ï¼Œåœ¨ä½ ä½œå‡ºæŸä¸ªè®¾è®¡å†³å®šä¹‹å‰ï¼Œè¯·åŠ¡å¿…ç†è§£è¯¥æ¨¡å¼çš„åº”ç”¨å‰æã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A <literal>Session</literal> is not thread-safe. Things that work "
-"concurrently, like HTTP requests, session beans, or Swing workers, will "
-"cause race conditions if a <literal>Session</literal> instance is shared. If "
-"you keep your Hibernate <literal>Session</literal> in your "
-"<literal>HttpSession</literal> (this is discussed later in the chapter), you "
-"should consider synchronizing access to your Http session. Otherwise, a user "
-"that clicks reload fast enough can use the same <literal>Session</literal> "
-"in two concurrently running threads."
-msgstr ""
-"<literal>Session</literal> 对象是非线程安全的。如果一个 <literal>Session</"
-"literal> 实例允许共享的话，那些支持并发运行的东东，例如 HTTP request，"
-"session beans 或者是 Swing workers，将会导致出现资源争用（race condition）。"
-"如果在 <literal>HttpSession</literal> 中有 Hibernate 的 <literal>Session</"
-"literal> çš„è¯ï¼ˆç¨åŽè®¨è®ºï¼‰ï¼Œä½ åº”è¯¥è€ƒè™‘åŒæ­¥è®¿é—®ä½ çš„ Http session。 否则，只要用"
-"户足够快的点击浏览器的“刷新”，就会导致两个并发运行线程使用同一个  "
-"<literal>Session</literal>。 "
+msgid "A <literal>Session</literal> is not thread-safe. Things that work concurrently, like HTTP requests, session beans, or Swing workers, will cause race conditions if a <literal>Session</literal> instance is shared. If you keep your Hibernate <literal>Session</literal> in your <literal>HttpSession</literal> (this is discussed later in the chapter), you should consider synchronizing access to your Http session. Otherwise, a user that clicks reload fast enough can use the same <literal>Session</literal> in two concurrently running threads."
+msgstr "<literal>Session</literal> 对象是非线程安全的。如果一个 <literal>Session</literal> 实例允许共享的话，那些支持并发运行的东东，例如 HTTP request，session beans 或者是 Swing workers，将会导致出现资源争用（race condition）。如果在 <literal>HttpSession</literal> 中有 Hibernate çš„ <literal>Session</literal> çš„è¯ï¼ˆç¨åŽè®¨è®ºï¼‰ï¼Œä½ åº”è¯¥è€ƒè™‘åŒæ­¥è®¿é—®ä½ çš„ Http session。 否则，只要用户足够快的点击浏览器的“刷新”，就会导致两个并发运行线程使用同一个  <literal>Session</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An exception thrown by Hibernate means you have to rollback your database "
-"transaction and close the <literal>Session</literal> immediately (this is "
-"discussed in more detail later in the chapter). If your <literal>Session</"
-"literal> is bound to the application, you have to stop the application. "
-"Rolling back the database transaction does not put your business objects "
-"back into the state they were at the start of the transaction. This means "
-"that the database state and the business objects will be out of sync. "
-"Usually this is not a problem, because exceptions are not recoverable and "
-"you will have to start over after rollback anyway."
-msgstr ""
-"一个由 Hibernate æŠ›å‡ºçš„å¼‚å¸¸æ„å‘³ç€ä½ å¿…é¡»ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œå¹¶ç«‹å³å…³é—­ "
-"<literal>Session</literal>ï¼ˆç¨åŽä¼šå±•å¼€è®¨è®ºï¼‰ã€‚å¦‚æžœä½ çš„ <literal>Session</"
-"literal> ç»‘å®šåˆ°ä¸€ä¸ªåº”ç”¨ç¨‹åºä¸Šï¼Œä½ å¿…é¡»åœæ­¢è¯¥åº”ç”¨ç¨‹åºã€‚å›žæ»šæ•°æ®åº“äº‹åŠ¡å¹¶ä¸ä¼šæŠŠä½ "
-"的业务对象退回到事务启动时候的状态。这意味着数据库状态和业务对象状态不同步。"
-"é€šå¸¸æƒ…å†µä¸‹ï¼Œè¿™ä¸æ˜¯ä»€ä¹ˆé—®é¢˜ï¼Œå› ä¸ºå¼‚å¸¸æ˜¯ä¸å¯æ¢å¤çš„ï¼Œä½ å¿…é¡»åœ¨å›žæ»šä¹‹åŽé‡æ–°å¼€å§‹æ‰§"
-"行。 "
+msgid "An exception thrown by Hibernate means you have to rollback your database transaction and close the <literal>Session</literal> immediately (this is discussed in more detail later in the chapter). If your <literal>Session</literal> is bound to the application, you have to stop the application. Rolling back the database transaction does not put your business objects back into the state they were at the start of the transaction. This means that the database state and the business objects will be out of sync. Usually this is not a problem, because exceptions are not recoverable and you will have to start over after rollback anyway."
+msgstr "一个由 Hibernate æŠ›å‡ºçš„å¼‚å¸¸æ„å‘³ç€ä½ å¿…é¡»ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œå¹¶ç«‹å³å…³é—­ <literal>Session</literal>ï¼ˆç¨åŽä¼šå±•å¼€è®¨è®ºï¼‰ã€‚å¦‚æžœä½ çš„ <literal>Session</literal> ç»‘å®šåˆ°ä¸€ä¸ªåº”ç”¨ç¨‹åºä¸Šï¼Œä½ å¿…é¡»åœæ­¢è¯¥åº”ç”¨ç¨‹åºã€‚å›žæ»šæ•°æ®åº“äº‹åŠ¡å¹¶ä¸ä¼šæŠŠä½ çš„ä¸šåŠ¡å¯¹è±¡é€€å›žåˆ°äº‹åŠ¡å¯åŠ¨æ—¶å€™çš„çŠ¶æ€ã€‚è¿™æ„å‘³ç€æ•°æ®åº“çŠ¶æ€å’Œä¸šåŠ¡å¯¹è±¡çŠ¶æ€ä¸åŒæ­¥ã€‚é€šå¸¸æƒ…å†µä¸‹ï¼Œè¿™ä¸æ˜¯ä»€ä¹ˆé—®é¢˜ï¼Œå› ä¸ºå¼‚å¸¸æ˜¯ä¸å¯æ¢å¤çš„ï¼Œä½ å¿…é¡»åœ¨å›žæ»šä¹‹åŽé‡æ–°å¼€å§‹æ‰§è¡Œã€‚ "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>Session</literal> caches every object that is in a persistent "
-"state (watched and checked for dirty state by Hibernate). If you keep it "
-"open for a long time or simply load too much data, it will grow endlessly "
-"until you get an OutOfMemoryException. One solution is to call <literal>clear"
-"()</literal> and <literal>evict()</literal> to manage the <literal>Session</"
-"literal> cache, but you should consider a Stored Procedure if you need mass "
-"data operations. Some solutions are shown in <xref linkend=\"batch\" />. "
-"Keeping a <literal>Session</literal> open for the duration of a user session "
-"also means a higher probability of stale data."
-msgstr ""
-"<literal>Session</literal> 缓存了处于持久化状态的每个对象（Hibernate 会监视和"
-"检查脏数据）。 è¿™æ„å‘³ç€ï¼Œå¦‚æžœä½ è®© <literal>Session</literal> 打开很长一段时"
-"间，或是仅仅载入了过多的数据， <literal>Session</literal> å ç”¨çš„å†…å­˜ä¼šä¸€ç›´å¢ž"
-"长，直到抛出 OutOfMemoryException 异常。这个 问题的一个解决方法是调用 "
-"<literal>clear()</literal> 和 <literal>evict()</literal> 来管理 "
-"<literal>Session</literal> çš„ç¼“å­˜ï¼Œä½†æ˜¯å¦‚æžœä½ éœ€è¦å¤§æ‰¹é‡æ•°æ®æ“ä½œçš„è¯ï¼Œæœ€å¥½è€ƒè™‘"
-"使用存储过程。在<xref linkend=\"Batch_processing\"/>中有一些解决方案。在用户"
-"会话期间一直保持 <literal>Session</literal> 打开也意味着出现脏数据的可能性很"
-"高。 "
+#, no-c-format
+msgid "The <literal>Session</literal> caches every object that is in a persistent state (watched and checked for dirty state by Hibernate). If you keep it open for a long time or simply load too much data, it will grow endlessly until you get an OutOfMemoryException. One solution is to call <literal>clear()</literal> and <literal>evict()</literal> to manage the <literal>Session</literal> cache, but you should consider a Stored Procedure if you need mass data operations. Some solutions are shown in <xref linkend=\"batch\" />. Keeping a <literal>Session</literal> open for the duration of a user session also means a higher probability of stale data."
+msgstr "<literal>Session</literal> 缓存了处于持久化状态的每个对象（Hibernate 会监视和检查脏数据）。 è¿™æ„å‘³ç€ï¼Œå¦‚æžœä½ è®© <literal>Session</literal> 打开很长一段时间，或是仅仅载入了过多的数据， <literal>Session</literal> å ç”¨çš„å†…å­˜ä¼šä¸€ç›´å¢žé•¿ï¼Œç›´åˆ°æŠ›å‡º OutOfMemoryException 异常。这个 问题的一个解决方法是调用 <literal>clear()</literal> å’Œ <literal>evict()</literal> 来管理 <literal>Session</literal> çš„ç¼“å­˜ï¼Œä½†æ˜¯å¦‚æžœä½ éœ€è¦å¤§æ‰¹é‡æ•°æ®æ“ä½œçš„è¯ï¼Œæœ€å¥½è€ƒè™‘ä½¿ç”¨å­˜å‚¨è¿‡ç¨‹ã€‚åœ¨ <xref linkend=\"batch\" /> 中有一些解决方案。在用户会话期间一直保持 <literal>Session</literal> 打开也意味着出现脏数据的可能性很高。 "
 
 #. Tag: title
 #, no-c-format
@@ -613,64 +231,22 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Database, or system, transaction boundaries are always necessary. No "
-"communication with the database can occur outside of a database transaction "
-"(this seems to confuse many developers who are used to the auto-commit "
-"mode). Always use clear transaction boundaries, even for read-only "
-"operations. Depending on your isolation level and database capabilities this "
-"might not be required, but there is no downside if you always demarcate "
-"transactions explicitly. Certainly, a single database transaction is going "
-"to perform better than many small transactions, even for reading data."
-msgstr ""
-"æ•°æ®åº“ï¼ˆæˆ–è€…ç³»ç»Ÿï¼‰äº‹åŠ¡çš„å£°æ˜Žæ€»æ˜¯å¿…é¡»çš„ã€‚åœ¨æ•°æ®åº“äº‹åŠ¡ä¹‹å¤–ï¼Œå°±æ— æ³•å’Œæ•°æ®åº“é€šè®¯"
-"ï¼ˆè¿™å¯èƒ½ä¼šè®©é‚£äº›ä¹ æƒ¯äºŽè‡ªåŠ¨æäº¤äº‹åŠ¡æ¨¡å¼çš„å¼€å‘äººå‘˜æ„Ÿåˆ°è¿·æƒ‘ï¼‰ã€‚æ°¸è¿œä½¿ç”¨æ¸…æ™°çš„äº‹"
-"务声明，即使只读操作也是如此。进行 æ˜¾å¼çš„äº‹åŠ¡å£°æ˜Žå¹¶ä¸æ€»æ˜¯éœ€è¦çš„ï¼Œè¿™å–å†³äºŽä½ çš„"
-"äº‹åŠ¡éš”ç¦»çº§åˆ«å’Œæ•°æ®åº“çš„èƒ½åŠ›ï¼Œä½†ä¸ç®¡æ€Žä¹ˆè¯´ï¼Œå£°æ˜Žäº‹åŠ¡æ€»å½’æœ‰ç›Šæ— å®³ã€‚å½“ç„¶ï¼Œä¸€ä¸ªå•"
-"ç‹¬çš„æ•°æ®åº“äº‹åŠ¡æ€»æ˜¯æ¯”å¾ˆå¤šçç¢Žçš„äº‹åŠ¡æ€§èƒ½æ›´å¥½ï¼Œå³æ—¶å¯¹è¯»æ•°æ®è€Œè¨€ä¹Ÿæ˜¯ä¸€æ ·ã€‚ "
+msgid "Database, or system, transaction boundaries are always necessary. No communication with the database can occur outside of a database transaction (this seems to confuse many developers who are used to the auto-commit mode). Always use clear transaction boundaries, even for read-only operations. Depending on your isolation level and database capabilities this might not be required, but there is no downside if you always demarcate transactions explicitly. Certainly, a single database transaction is going to perform better than many small transactions, even for reading data."
+msgstr "æ•°æ®åº“ï¼ˆæˆ–è€…ç³»ç»Ÿï¼‰äº‹åŠ¡çš„å£°æ˜Žæ€»æ˜¯å¿…é¡»çš„ã€‚åœ¨æ•°æ®åº“äº‹åŠ¡ä¹‹å¤–ï¼Œå°±æ— æ³•å’Œæ•°æ®åº“é€šè®¯ï¼ˆè¿™å¯èƒ½ä¼šè®©é‚£äº›ä¹ æƒ¯äºŽè‡ªåŠ¨æäº¤äº‹åŠ¡æ¨¡å¼çš„å¼€å‘äººå‘˜æ„Ÿåˆ°è¿·æƒ‘ï¼‰ã€‚æ°¸è¿œä½¿ç”¨æ¸…æ™°çš„äº‹åŠ¡å£°æ˜Žï¼Œå³ä½¿åªè¯»æ“ä½œä¹Ÿæ˜¯å¦‚æ­¤ã€‚è¿›è¡Œ æ˜¾å¼çš„äº‹åŠ¡å£°æ˜Žå¹¶ä¸æ€»æ˜¯éœ€è¦çš„ï¼Œè¿™å–å†³äºŽä½ çš„äº‹åŠ¡éš”ç¦»çº§åˆ«å’Œæ•°æ®åº“çš„èƒ½åŠ›ï¼Œä½†ä¸ç®¡æ€Žä¹ˆè¯´ï¼Œå£°æ˜Žäº‹åŠ¡æ€»å½’æœ‰ç›Šæ— å®³ã€‚å½“ç„¶ï¼Œä¸€ä¸ªå•ç‹¬çš„æ•°æ®åº“äº‹åŠ¡æ€»æ˜¯æ¯”å¾ˆå¤šçç¢Žçš„äº‹åŠ¡æ€§èƒ½æ›´å¥½ï¼Œå³æ—¶å¯¹è¯»æ•°æ®è€Œè¨€ä¹Ÿæ˜¯ä¸€æ ·ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A Hibernate application can run in non-managed (i.e., standalone, simple "
-"Web- or Swing applications) and managed J2EE environments. In a non-managed "
-"environment, Hibernate is usually responsible for its own database "
-"connection pool. The application developer has to manually set transaction "
-"boundaries (begin, commit, or rollback database transactions) themselves. A "
-"managed environment usually provides container-managed transactions (CMT), "
-"with the transaction assembly defined declaratively (in deployment "
-"descriptors of EJB session beans, for example). Programmatic transaction "
-"demarcation is then no longer necessary."
-msgstr ""
-"一个 Hibernate 应用程序可以运行在非托管环境中（也就是独立运行的应用程序，简"
-"单 Web 应用程序，或者Swing图形桌面应用程序），也可以运行在托管的 J2EE 环境"
-"中。在一个非托管环境中，Hibernate é€šå¸¸è‡ªå·±è´Ÿè´£ç®¡ç†æ•°æ®åº“è¿žæŽ¥æ± ã€‚åº”ç”¨ç¨‹åºå¼€å‘"
-"人员必须手工设置事务声明，换句话说，就是手工启 动，提交，或者回滚数据库事务。"
-"一个托管的环境通常提供了容器管理事务（CMT），例如事务装配通过可声明的方式定义"
-"在 EJB session beans 的部署描述符中。可编程式事务声明不再需要，即使是 "
-"<literal>Session</literal> 的同步也可以自动完成。 "
+msgid "A Hibernate application can run in non-managed (i.e., standalone, simple Web- or Swing applications) and managed J2EE environments. In a non-managed environment, Hibernate is usually responsible for its own database connection pool. The application developer has to manually set transaction boundaries (begin, commit, or rollback database transactions) themselves. A managed environment usually provides container-managed transactions (CMT), with the transaction assembly defined declaratively (in deployment descriptors of EJB session beans, for example). Programmatic transaction demarcation is then no longer necessary."
+msgstr "一个 Hibernate 应用程序可以运行在非托管环境中（也就是独立运行的应用程序，简单 Web 应用程序，或者Swing图形桌面应用程序），也可以运行在托管的 J2EE 环境中。在一个非托管环境中，Hibernate é€šå¸¸è‡ªå·±è´Ÿè´£ç®¡ç†æ•°æ®åº“è¿žæŽ¥æ± ã€‚åº”ç”¨ç¨‹åºå¼€å‘äººå‘˜å¿…é¡»æ‰‹å·¥è®¾ç½®äº‹åŠ¡å£°æ˜Žï¼Œæ¢å¥è¯è¯´ï¼Œå°±æ˜¯æ‰‹å·¥å¯ 动，提交，或者回滚数据库事务。一个托管的环境通常提供了容器管理事务（CMT），例如事务装配通过可声明的方式定义在 EJB session beans 的部署描述符中。可编程式事务声明不再需要，即使是 <literal>Session</literal> 的同步也可以自动完成。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"However, it is often desirable to keep your persistence layer portable "
-"between non-managed resource-local environments, and systems that can rely "
-"on JTA but use BMT instead of CMT. In both cases use programmatic "
-"transaction demarcation. Hibernate offers a wrapper API called "
-"<literal>Transaction</literal> that translates into the native transaction "
-"system of your deployment environment. This API is actually optional, but we "
-"strongly encourage its use unless you are in a CMT session bean."
-msgstr ""
-"让持久层具备可移植性是人们的理想,这种移植发生在非托管的本地资源环境，与依赖 "
-"JTA 但是使用 BMT 而非 CMT çš„ç³»ç»Ÿä¹‹é—´ã€‚åœ¨ä¸¤ç§æƒ…å†µä¸‹ä½ éƒ½å¯ä»¥ä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡ç®¡"
-"理。Hibernate 提供了一套称为 <literal>Transaction</literal> 的封装 API， 用来"
-"æŠŠä½ çš„éƒ¨ç½²çŽ¯å¢ƒä¸­çš„æœ¬åœ°äº‹åŠ¡ç®¡ç†ç³»ç»Ÿè½¬æ¢åˆ° Hibernate 事务上。这个 API 是可选"
-"çš„ï¼Œä½†æ˜¯æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ ä½¿ç”¨ï¼Œé™¤éžä½ ç”¨ CMT session bean。 "
+msgid "However, it is often desirable to keep your persistence layer portable between non-managed resource-local environments, and systems that can rely on JTA but use BMT instead of CMT. In both cases use programmatic transaction demarcation. Hibernate offers a wrapper API called <literal>Transaction</literal> that translates into the native transaction system of your deployment environment. This API is actually optional, but we strongly encourage its use unless you are in a CMT session bean."
+msgstr "让持久层具备可移植性是人们的理想,这种移植发生在非托管的本地资源环境，与依赖 JTA 但是使用 BMT 而非 CMT çš„ç³»ç»Ÿä¹‹é—´ã€‚åœ¨ä¸¤ç§æƒ…å†µä¸‹ä½ éƒ½å¯ä»¥ä½¿ç”¨ç¼–ç¨‹å¼çš„äº‹åŠ¡ç®¡ç†ã€‚Hibernate 提供了一套称为 <literal>Transaction</literal> 的封装 API， ç”¨æ¥æŠŠä½ çš„éƒ¨ç½²çŽ¯å¢ƒä¸­çš„æœ¬åœ°äº‹åŠ¡ç®¡ç†ç³»ç»Ÿè½¬æ¢åˆ° Hibernate 事务上。这个 API æ˜¯å¯é€‰çš„ï¼Œä½†æ˜¯æˆ‘ä»¬å¼ºçƒˆæŽ¨èä½ ä½¿ç”¨ï¼Œé™¤éžä½ ç”¨ CMT session bean。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Ending a <literal>Session</literal> usually involves four distinct phases:"
+msgid "Ending a <literal>Session</literal> usually involves four distinct phases:"
 msgstr "通常情况下，结束 <literal>Session</literal> 包含了四个不同的阶段： "
 
 #. Tag: para
@@ -695,13 +271,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"We discussed Flushing the session earlier, so we will now have a closer look "
-"at transaction demarcation and exception handling in both managed and non-"
-"managed environments."
-msgstr ""
-"session 的同步（flush，刷出）前面已经讨论过了，我们现在进一步考察在托管和非托"
-"管环境下的事务声明和异常处理。 "
+msgid "We discussed Flushing the session earlier, so we will now have a closer look at transaction demarcation and exception handling in both managed and non-managed environments."
+msgstr "session 的同步（flush，刷出）前面已经讨论过了，我们现在进一步考察在托管和非托管环境下的事务声明和异常处理。 "
 
 #. Tag: title
 #, no-c-format
@@ -710,73 +281,28 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If a Hibernate persistence layer runs in a non-managed environment, database "
-"connections are usually handled by simple (i.e., non-DataSource) connection "
-"pools from which Hibernate obtains connections as needed. The session/"
-"transaction handling idiom looks like this:"
-msgstr ""
-"如果 Hibernat 持久层运行在一个非托管环境中，数据库连接通常由 Hibernate 的简单"
-"（即非 DataSourceï¼‰è¿žæŽ¥æ± æœºåˆ¶ 来处理。session/transaction 处理方式如下所示： "
+msgid "If a Hibernate persistence layer runs in a non-managed environment, database connections are usually handled by simple (i.e., non-DataSource) connection pools from which Hibernate obtains connections as needed. The session/transaction handling idiom looks like this:"
+msgstr "如果 Hibernat 持久层运行在一个非托管环境中，数据库连接通常由 Hibernate 的简单（即非 DataSourceï¼‰è¿žæŽ¥æ± æœºåˆ¶ 来处理。session/transaction 处理方式如下所示： "
 
 #. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You do not have to <literal>flush()</literal> the <literal>Session</literal> "
-"explicitly: the call to <literal>commit()</literal> automatically triggers "
-"the synchronization depending on the <xref linkend=\"objectstate-flushing\" /"
-"> for the session. A call to <literal>close()</literal> marks the end of a "
-"session. The main implication of <literal>close()</literal> is that the JDBC "
-"connection will be relinquished by the session. This Java code is portable "
-"and runs in both non-managed and JTA environments."
-msgstr ""
-"ä½ ä¸éœ€è¦æ˜¾å¼ <literal>flush()</literal> <literal>Session</literal> — 对 "
-"<literal>commit()</literal> 的调用会自动触发 session 的同步（取决于 session "
-"的 <xref linkend=\"objectstate-flushing\">FlushMode</xref>）。调用 "
-"<literal>close()</literal> æ ‡å¿— session 的结束。<literal>close()</literal> æ–¹"
-"法重要的暗示是，<literal>session</literal> 释放了 JDBC 连接。这段 Java ä»£ç åœ¨"
-"非托管环境下和 JTA 环境下都可以运行。 "
+#, no-c-format
+msgid "You do not have to <literal>flush()</literal> the <literal>Session</literal> explicitly: the call to <literal>commit()</literal> automatically triggers the synchronization depending on the <xref linkend=\"objectstate-flushing\" /> for the session. A call to <literal>close()</literal> marks the end of a session. The main implication of <literal>close()</literal> is that the JDBC connection will be relinquished by the session. This Java code is portable and runs in both non-managed and JTA environments."
+msgstr "ä½ ä¸éœ€è¦æ˜¾å¼ <literal>flush()</literal> <literal>Session</literal> — 对 <literal>commit()</literal> 的调用会自动触发 session 的同步（取决于 session çš„ <xref linkend=\"objectstate-flushing\">FlushMode</xref>）。调用 <literal>close()</literal> æ ‡å¿— session 的结束。<literal>close()</literal> 方法重要的暗示是，<literal>session</literal> 释放了 JDBC 连接。这段 Java ä»£ç åœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸‹å’Œ JTA 环境下都可以运行。  "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"As outlined earlier, a much more flexible solution is Hibernate's built-in "
-"\"current session\" context management:"
-msgstr ""
-"æ›´åŠ çµæ´»çš„æ–¹æ¡ˆæ˜¯ Hibernate 内置的 \"current session\" 上下文管理，前文已经讲"
-"过： "
+msgid "As outlined earlier, a much more flexible solution is Hibernate's built-in \"current session\" context management:"
+msgstr "æ›´åŠ çµæ´»çš„æ–¹æ¡ˆæ˜¯ Hibernate 内置的 \"current session\" 上下文管理，前文已经讲过： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You will not see these code snippets in a regular application; fatal "
-"(system) exceptions should always be caught at the \"top\". In other words, "
-"the code that executes Hibernate calls in the persistence layer, and the "
-"code that handles <literal>RuntimeException</literal> (and usually can only "
-"clean up and exit), are in different layers. The current context management "
-"by Hibernate can significantly simplify this design by accessing a "
-"<literal>SessionFactory</literal>. Exception handling is discussed later in "
-"this chapter."
-msgstr ""
-"ä½ å¾ˆå¯èƒ½ä»Žæœªåœ¨ä¸€ä¸ªé€šå¸¸çš„åº”ç”¨ç¨‹åºçš„ä¸šåŠ¡ä»£ç ä¸­è§è¿‡è¿™æ ·çš„ä»£ç ç‰‡æ–­ï¼šè‡´å‘½çš„ï¼ˆç³»"
-"统）异常应该总是 在应用程序“顶层”被捕获。换句话说，执行 Hibernate è°ƒç”¨çš„ä»£ç "
-"（在持久层）和处理 <literal>RuntimeException</literal> å¼‚å¸¸çš„ä»£ç ï¼ˆé€šå¸¸åªèƒ½æ¸…"
-"理和退出应用程序）应该在不同 的应用程序逻辑层。Hibernate 的当前上下文管理可以"
-"æžå¤§åœ°ç®€åŒ–è¿™ä¸€è®¾è®¡ï¼Œä½ æ‰€æœ‰çš„ä¸€åˆ‡å°±æ˜¯ <literal>SessionFactory</literal>。异常"
-"å¤„ç†å°†åœ¨æœ¬ç« ç¨åŽè¿›è¡Œè®¨è®ºã€‚ "
+msgid "You will not see these code snippets in a regular application; fatal (system) exceptions should always be caught at the \"top\". In other words, the code that executes Hibernate calls in the persistence layer, and the code that handles <literal>RuntimeException</literal> (and usually can only clean up and exit), are in different layers. The current context management by Hibernate can significantly simplify this design by accessing a <literal>SessionFactory</literal>. Exception handling is discussed later in this chapter."
+msgstr "ä½ å¾ˆå¯èƒ½ä»Žæœªåœ¨ä¸€ä¸ªé€šå¸¸çš„åº”ç”¨ç¨‹åºçš„ä¸šåŠ¡ä»£ç ä¸­è§è¿‡è¿™æ ·çš„ä»£ç ç‰‡æ–­ï¼šè‡´å‘½çš„ï¼ˆç³»ç»Ÿï¼‰å¼‚å¸¸åº”è¯¥æ€»æ˜¯ 在应用程序“顶层”被捕获。换句话说，执行 Hibernate è°ƒç”¨çš„ä»£ç ï¼ˆåœ¨æŒä¹…å±‚ï¼‰å’Œå¤„ç† <literal>RuntimeException</literal> å¼‚å¸¸çš„ä»£ç ï¼ˆé€šå¸¸åªèƒ½æ¸…ç†å’Œé€€å‡ºåº”ç”¨ç¨‹åºï¼‰åº”è¯¥åœ¨ä¸åŒ 的应用程序逻辑层。Hibernate çš„å½“å‰ä¸Šä¸‹æ–‡ç®¡ç†å¯ä»¥æžå¤§åœ°ç®€åŒ–è¿™ä¸€è®¾è®¡ï¼Œä½ æ‰€æœ‰çš„ä¸€åˆ‡å°±æ˜¯ <literal>SessionFactory</literal>ã€‚å¼‚å¸¸å¤„ç†å°†åœ¨æœ¬ç« ç¨åŽè¿›è¡Œè®¨è®ºã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You should select <literal>org.hibernate.transaction.JDBCTransactionFactory</"
-"literal>, which is the default, and for the second example select <literal>"
-"\"thread\"</literal> as your <literal>hibernate."
-"current_session_context_class</literal>."
-msgstr ""
-"è¯·æ³¨æ„ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction."
-"JDBCTransactionFactory</literal> （这是默认选项），对第二个例子来说，"
-"<literal>hibernate.current_session_context_class</literal>应该是 <literal>"
-"\"thread\"</literal>。"
+msgid "You should select <literal>org.hibernate.transaction.JDBCTransactionFactory</literal>, which is the default, and for the second example select <literal>\"thread\"</literal> as your <literal>hibernate.current_session_context_class</literal>."
+msgstr "è¯·æ³¨æ„ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction.JDBCTransactionFactory</literal> （这是默认选项），对第二个例子来说，<literal>hibernate.current_session_context_class</literal>应该是 <literal>\"thread\"</literal>。"
 
 #. Tag: title
 #, no-c-format
@@ -785,110 +311,38 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If your persistence layer runs in an application server (for example, behind "
-"EJB session beans), every datasource connection obtained by Hibernate will "
-"automatically be part of the global JTA transaction. You can also install a "
-"standalone JTA implementation and use it without EJB. Hibernate offers two "
-"strategies for JTA integration."
-msgstr ""
-"å¦‚æžœä½ çš„æŒä¹…å±‚è¿è¡Œåœ¨ä¸€ä¸ªåº”ç”¨æœåŠ¡å™¨ä¸­ï¼ˆä¾‹å¦‚ï¼Œåœ¨ EJB session beans 的后面），"
-"Hibernate 获取的每个数据源连接将自动成为全局 JTA äº‹åŠ¡çš„ä¸€éƒ¨åˆ†ã€‚ä½ å¯ä»¥å®‰è£…ä¸€ä¸ª"
-"独立的 JTA 实现，使用它而不使用 EJB。Hibernate 提供了两种策略进行 JTA 集成。 "
+msgid "If your persistence layer runs in an application server (for example, behind EJB session beans), every datasource connection obtained by Hibernate will automatically be part of the global JTA transaction. You can also install a standalone JTA implementation and use it without EJB. Hibernate offers two strategies for JTA integration."
+msgstr "å¦‚æžœä½ çš„æŒä¹…å±‚è¿è¡Œåœ¨ä¸€ä¸ªåº”ç”¨æœåŠ¡å™¨ä¸­ï¼ˆä¾‹å¦‚ï¼Œåœ¨ EJB session beans 的后面），Hibernate 获取的每个数据源连接将自动成为全局 JTA äº‹åŠ¡çš„ä¸€éƒ¨åˆ†ã€‚ä½ å¯ä»¥å®‰è£…ä¸€ä¸ªç‹¬ç«‹çš„ JTA 实现，使用它而不使用 EJB。Hibernate 提供了两种策略进行 JTA 集成。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you use bean-managed transactions (BMT), Hibernate will tell the "
-"application server to start and end a BMT transaction if you use the "
-"<literal>Transaction</literal> API. The transaction management code is "
-"identical to the non-managed environment."
-msgstr ""
-"å¦‚æžœä½ ä½¿ç”¨ bean 管理事务（BMT），可以通过使用 Hibernate çš„ "
-"<literal>Transaction</literal> API 来告诉应用服务器启动和结束 BMT äº‹åŠ¡ã€‚å› "
-"æ­¤ï¼Œäº‹åŠ¡ç®¡ç†ä»£ç å’Œåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸‹æ˜¯ä¸€æ ·çš„ã€‚ "
+msgid "If you use bean-managed transactions (BMT), Hibernate will tell the application server to start and end a BMT transaction if you use the <literal>Transaction</literal> API. The transaction management code is identical to the non-managed environment."
+msgstr "å¦‚æžœä½ ä½¿ç”¨ bean 管理事务（BMT），可以通过使用 Hibernate çš„ <literal>Transaction</literal> API 来告诉应用服务器启动和结束 BMT äº‹åŠ¡ã€‚å› æ­¤ï¼Œäº‹åŠ¡ç®¡ç†ä»£ç å’Œåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸‹æ˜¯ä¸€æ ·çš„ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you want to use a transaction-bound <literal>Session</literal>, that is, "
-"the <literal>getCurrentSession()</literal> functionality for easy context "
-"propagation, use the JTA <literal>UserTransaction</literal> API directly:"
-msgstr ""
-"å¦‚æžœä½ å¸Œæœ›ä½¿ç”¨ä¸Žäº‹åŠ¡ç»‘å®šçš„ <literal>Session</literal>，也就是使用 "
-"<literal>getCurrentSession()</literal> æ¥ç®€åŒ–ä¸Šä¸‹æ–‡ç®¡ç†ï¼Œä½ å°†ä¸å¾—ä¸ç›´æŽ¥ä½¿ç”¨ "
-"JTA  <literal>UserTransaction</literal> API。 "
+msgid "If you want to use a transaction-bound <literal>Session</literal>, that is, the <literal>getCurrentSession()</literal> functionality for easy context propagation, use the JTA <literal>UserTransaction</literal> API directly:"
+msgstr "å¦‚æžœä½ å¸Œæœ›ä½¿ç”¨ä¸Žäº‹åŠ¡ç»‘å®šçš„ <literal>Session</literal>，也就是使用 <literal>getCurrentSession()</literal> æ¥ç®€åŒ–ä¸Šä¸‹æ–‡ç®¡ç†ï¼Œä½ å°†ä¸å¾—ä¸ç›´æŽ¥ä½¿ç”¨ JTA  <literal>UserTransaction</literal> API。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"With CMT, transaction demarcation is completed in session bean deployment "
-"descriptors, not programmatically. The code is reduced to:"
-msgstr ""
-"在 CMT 方式下，事务声明是在 session bean çš„éƒ¨ç½²æè¿°ç¬¦ä¸­ï¼Œè€Œä¸éœ€è¦ç¼–ç¨‹ã€‚å› æ­¤ï¼Œ"
-"ä»£ç è¢«ç®€åŒ–ä¸ºï¼š"
+msgid "With CMT, transaction demarcation is completed in session bean deployment descriptors, not programmatically. The code is reduced to:"
+msgstr "在 CMT 方式下，事务声明是在 session bean çš„éƒ¨ç½²æè¿°ç¬¦ä¸­ï¼Œè€Œä¸éœ€è¦ç¼–ç¨‹ã€‚å› æ­¤ï¼Œä»£ç è¢«ç®€åŒ–ä¸ºï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In a CMT/EJB, even rollback happens automatically. An unhandled "
-"<literal>RuntimeException</literal> thrown by a session bean method tells "
-"the container to set the global transaction to rollback. <emphasis>You do "
-"not need to use the Hibernate <literal>Transaction</literal> API at all with "
-"BMT or CMT, and you get automatic propagation of the \"current\" Session "
-"bound to the transaction.</emphasis>"
-msgstr ""
-"在 CMT/EJB 中甚至会自动 rollbackï¼Œå› ä¸ºå‡è‹¥æœ‰æœªæ•èŽ·çš„ "
-"<literal>RuntimeException</literal> 从 session bean 方法中抛出，这就会通知容"
-"器把全局事务回滚。<emphasis>这就意味着，在 BMT 或者 CMT ä¸­ï¼Œä½ æ ¹æœ¬å°±ä¸éœ€è¦ä½¿"
-"用 Hibernate <literal>Transaction</literal> APIï¼Œä½ è‡ªåŠ¨å¾—åˆ°äº†ç»‘å®šåˆ°äº‹åŠ¡çš„â€œå½“"
-"前” Session。</emphasis>"
+msgid "In a CMT/EJB, even rollback happens automatically. An unhandled <literal>RuntimeException</literal> thrown by a session bean method tells the container to set the global transaction to rollback. <emphasis>You do not need to use the Hibernate <literal>Transaction</literal> API at all with BMT or CMT, and you get automatic propagation of the \"current\" Session bound to the transaction.</emphasis>"
+msgstr "在 CMT/EJB 中甚至会自动 rollbackï¼Œå› ä¸ºå‡è‹¥æœ‰æœªæ•èŽ·çš„ <literal>RuntimeException</literal> 从 session bean 方法中抛出，这就会通知容器把全局事务回滚。<emphasis>这就意味着，在 BMT 或者 CMT ä¸­ï¼Œä½ æ ¹æœ¬å°±ä¸éœ€è¦ä½¿ç”¨ Hibernate <literal>Transaction</literal> APIï¼Œä½ è‡ªåŠ¨å¾—åˆ°äº†ç»‘å®šåˆ°äº‹åŠ¡çš„â€œå½“å‰â€ Session。</emphasis>"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"When configuring Hibernate's transaction factory, choose <literal>org."
-"hibernate.transaction.JTATransactionFactory</literal> if you use JTA "
-"directly (BMT), and <literal>org.hibernate.transaction."
-"CMTTransactionFactory</literal> in a CMT session bean. Remember to also set "
-"<literal>hibernate.transaction.manager_lookup_class</literal>. Ensure that "
-"your <literal>hibernate.current_session_context_class</literal> is either "
-"unset (backwards compatibility), or is set to <literal>\"jta\"</literal>."
-msgstr ""
-"æ³¨æ„ï¼Œå½“ä½ é…ç½® Hibernate çš„ transaction factory 的时候，在直接使用 JTA 的时候"
-"（BMTï¼‰ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction."
-"JTATransactionFactory</literal>，在 CMT session bean 中选择 <literal>org."
-"hibernate.transaction.CMTTransactionFactory</literal>。记得也要设置 "
-"<literal>hibernate.transaction.manager_lookup_class</literal>ã€‚è¿˜æœ‰ï¼Œç¡®è®¤ä½ "
-"的 <literal>hibernate.current_session_context_class</literal> 未设置（为了向"
-"下兼容），或者设置为 <literal>\"jta\"</literal>。 "
+msgid "When configuring Hibernate's transaction factory, choose <literal>org.hibernate.transaction.JTATransactionFactory</literal> if you use JTA directly (BMT), and <literal>org.hibernate.transaction.CMTTransactionFactory</literal> in a CMT session bean. Remember to also set <literal>hibernate.transaction.manager_lookup_class</literal>. Ensure that your <literal>hibernate.current_session_context_class</literal> is either unset (backwards compatibility), or is set to <literal>\"jta\"</literal>."
+msgstr "æ³¨æ„ï¼Œå½“ä½ é…ç½® Hibernate çš„ transaction factory 的时候，在直接使用 JTA 的时候（BMTï¼‰ï¼Œä½ åº”è¯¥é€‰æ‹© <literal>org.hibernate.transaction.JTATransactionFactory</literal>，在 CMT session bean 中选择 <literal>org.hibernate.transaction.CMTTransactionFactory</literal>。记得也要设置 <literal>hibernate.transaction.manager_lookup_class</literal>ã€‚è¿˜æœ‰ï¼Œç¡®è®¤ä½ çš„ <literal>hibernate.current_session_context_class</literal> 未设置（为了向下兼容），或者设置为 <literal>\"jta\"</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>getCurrentSession()</literal> operation has one downside in a "
-"JTA environment. There is one caveat to the use of <literal>after_statement</"
-"literal> connection release mode, which is then used by default. Due to a "
-"limitation of the JTA spec, it is not possible for Hibernate to "
-"automatically clean up any unclosed <literal>ScrollableResults</literal> or "
-"<literal>Iterator</literal> instances returned by <literal>scroll()</"
-"literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> "
-"release the underlying database cursor by calling <literal>ScrollableResults."
-"close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicitly "
-"from a <literal>finally</literal> block. Most applications can easily avoid "
-"using <literal>scroll()</literal> or <literal>iterate()</literal> from the "
-"JTA or CMT code.)"
-msgstr ""
-"<literal>getCurrentSession()</literal>在 JTA 环境中有一个弊端。对 "
-"<literal>after_statement</literal> 连接释放方式有一个警告，这是被默认使用的。"
-"å› ä¸º JTA è§„èŒƒçš„ä¸€ä¸ªå¾ˆæ„šè ¢çš„é™åˆ¶ï¼ŒHibernate 不可能自动清理任何未关闭的 "
-"<literal>ScrollableResults</literal> 或者<literal>Iterator</literal>，它们是"
-"ç”± <literal>scroll()</literal> 或 <literal>iterate()</literal> äº§ç”Ÿçš„ã€‚ä½  "
-"<emphasis>must</emphasis> 通过在 <literal>finally</literal> 块中，显式调用 "
-"<literal>ScrollableResults.close()</literal> 或者 <literal>Hibernate.close"
-"(Iterator)</literal> æ–¹æ³•æ¥é‡Šæ”¾åº•å±‚æ•°æ®åº“æ¸¸æ ‡ã€‚ï¼ˆå½“ç„¶ï¼Œå¤§éƒ¨åˆ†ç¨‹åºå®Œå…¨å¯ä»¥å¾ˆå®¹"
-"易的避免在 JTA 或 CMT ä»£ç ä¸­å‡ºçŽ° <literal>scroll()</literal> 或 "
-"<literal>iterate()</literal>。） "
+msgid "The <literal>getCurrentSession()</literal> operation has one downside in a JTA environment. There is one caveat to the use of <literal>after_statement</literal> connection release mode, which is then used by default. Due to a limitation of the JTA spec, it is not possible for Hibernate to automatically clean up any unclosed <literal>ScrollableResults</literal> or <literal>Iterator</literal> instances returned by <literal>scroll()</literal> or <literal>iterate()</literal>. You <emphasis>must</emphasis> release the underlying database cursor by calling <literal>ScrollableResults.close()</literal> or <literal>Hibernate.close(Iterator)</literal> explicitly from a <literal>finally</literal> block. Most applications can easily avoid using <literal>scroll()</literal> or <literal>iterate()</literal> from the JTA or CMT code.)"
+msgstr "<literal>getCurrentSession()</literal>在 JTA 环境中有一个弊端。对 <literal>after_statement</literal> è¿žæŽ¥é‡Šæ”¾æ–¹å¼æœ‰ä¸€ä¸ªè­¦å‘Šï¼Œè¿™æ˜¯è¢«é»˜è®¤ä½¿ç”¨çš„ã€‚å› ä¸º JTA è§„èŒƒçš„ä¸€ä¸ªå¾ˆæ„šè ¢çš„é™åˆ¶ï¼ŒHibernate 不可能自动清理任何未关闭的 <literal>ScrollableResults</literal> 或者<literal>Iterator</literal>，它们是由 <literal>scroll()</literal> 或 <literal>iterate()</literal> äº§ç”Ÿçš„ã€‚ä½  <emphasis>must</emphasis> 通过在 <literal>finally</literal> 块中，显式调用 <literal>ScrollableResults.close()</literal> 或者 <literal>Hibernate.close(Iterator)</literal> æ–¹æ³•æ¥é‡Šæ”¾åº•å±‚æ•°æ®åº“æ¸¸æ ‡ã€‚ï¼ˆå½“ç„¶ï¼Œå¤§éƒ¨åˆ†ç¨‹åºå®Œå…¨å¯ä»¥å¾ˆå®¹æ˜“çš„é¿å…åœ¨ JTA 或 CMT ä»£ç ä¸­å‡ºçŽ° <literal>scroll()</literal> 或 <literal>iterate()</literal>。） "
 
 #. Tag: title
 #, no-c-format
@@ -897,117 +351,43 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If the <literal>Session</literal> throws an exception, including any "
-"<literal>SQLException</literal>, immediately rollback the database "
-"transaction, call <literal>Session.close()</literal> and discard the "
-"<literal>Session</literal> instance. Certain methods of <literal>Session</"
-"literal> will <emphasis>not</emphasis> leave the session in a consistent "
-"state. No exception thrown by Hibernate can be treated as recoverable. "
-"Ensure that the <literal>Session</literal> will be closed by calling "
-"<literal>close()</literal> in a <literal>finally</literal> block."
-msgstr ""
-"如果 <literal>Session</literal> 抛出异常（包括任何 <literal>SQLException</"
-"literal>ï¼‰ï¼Œä½ åº”è¯¥ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œè°ƒç”¨ <literal>Session.close()</"
-"literal> ，丢弃该  <literal>Session</literal> 实例。<literal>Session</"
-"literal> 的某些方法可能会导致 session 处于不一致的状态。所有由 Hibernate 抛出"
-"的异常都视为不可以恢复的。确保在  <literal>finally</literal> ä»£ç å—ä¸­è°ƒç”¨ "
-"<literal>close()</literal> 方法，以关闭掉  <literal>Session</literal>。"
+msgid "If the <literal>Session</literal> throws an exception, including any <literal>SQLException</literal>, immediately rollback the database transaction, call <literal>Session.close()</literal> and discard the <literal>Session</literal> instance. Certain methods of <literal>Session</literal> will <emphasis>not</emphasis> leave the session in a consistent state. No exception thrown by Hibernate can be treated as recoverable. Ensure that the <literal>Session</literal> will be closed by calling <literal>close()</literal> in a <literal>finally</literal> block."
+msgstr "如果 <literal>Session</literal> 抛出异常（包括任何 <literal>SQLException</literal>ï¼‰ï¼Œä½ åº”è¯¥ç«‹å³å›žæ»šæ•°æ®åº“äº‹åŠ¡ï¼Œè°ƒç”¨ <literal>Session.close()</literal> ，丢弃该  <literal>Session</literal> 实例。<literal>Session</literal> 的某些方法可能会导致 session 处于不一致的状态。所有由 Hibernate 抛出的异常都视为不可以恢复的。确保在  <literal>finally</literal> ä»£ç å—ä¸­è°ƒç”¨ <literal>close()</literal> 方法，以关闭掉  <literal>Session</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>HibernateException</literal>, which wraps most of the errors "
-"that can occur in a Hibernate persistence layer, is an unchecked exception. "
-"It was not in older versions of Hibernate. In our opinion, we should not "
-"force the application developer to catch an unrecoverable exception at a low "
-"layer. In most systems, unchecked and fatal exceptions are handled in one of "
-"the first frames of the method call stack (i.e., in higher layers) and "
-"either an error message is presented to the application user or some other "
-"appropriate action is taken. Note that Hibernate might also throw other "
-"unchecked exceptions that are not a <literal>HibernateException</literal>. "
-"These are not recoverable and appropriate action should be taken."
-msgstr ""
-"<literal>HibernateException</literal> 是一个非检查期异常（这不同于 Hibernate "
-"老的版本），它封装了 Hibernate 持久层可能出现的大多数错误。我们的观点是，不应"
-"该强迫应用程序开发人员 åœ¨åº•å±‚æ•èŽ·æ— æ³•æ¢å¤çš„å¼‚å¸¸ã€‚åœ¨å¤§å¤šæ•°è½¯ä»¶ç³»ç»Ÿä¸­ï¼Œéžæ£€æŸ¥æœŸ"
-"异常和致命异常都是在相应方法调用 çš„å †æ ˆçš„é¡¶å±‚è¢«å¤„ç†çš„ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œåœ¨è½¯ä»¶ä¸Šé¢çš„"
-"逻辑层），并且提供一个错误信息给应用软件的用户 （或者采取其他某些相应的操"
-"作）。请注意，Hibernate 也有可能抛出其他并不属于 "
-"<literal>HibernateException</literal> çš„éžæ£€æŸ¥æœŸå¼‚å¸¸ã€‚è¿™äº›å¼‚å¸¸åŒæ ·ä¹Ÿæ˜¯æ— æ³•æ¢"
-"复的，应该 采取某些相应的操作去处理。"
+msgid "The <literal>HibernateException</literal>, which wraps most of the errors that can occur in a Hibernate persistence layer, is an unchecked exception. It was not in older versions of Hibernate. In our opinion, we should not force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e., in higher layers) and either an error message is presented to the application user or some other appropriate action is taken. Note that Hibernate might also throw other unchecked exceptions that are not a <literal>HibernateException</literal>. These are not recoverable and appropriate action should be taken."
+msgstr "<literal>HibernateException</literal> 是一个非检查期异常（这不同于 Hibernate 老的版本），它封装了 Hibernate 持久层可能出现的大多数错误。我们的观点是，不应该强迫应用程序开发人员 åœ¨åº•å±‚æ•èŽ·æ— æ³•æ¢å¤çš„å¼‚å¸¸ã€‚åœ¨å¤§å¤šæ•°è½¯ä»¶ç³»ç»Ÿä¸­ï¼Œéžæ£€æŸ¥æœŸå¼‚å¸¸å’Œè‡´å‘½å¼‚å¸¸éƒ½æ˜¯åœ¨ç›¸åº”æ–¹æ³•è°ƒç”¨ çš„å †æ ˆçš„é¡¶å±‚è¢«å¤„ç†çš„ï¼ˆä¹Ÿå°±æ˜¯è¯´ï¼Œåœ¨è½¯ä»¶ä¸Šé¢çš„é€»è¾‘å±‚ï¼‰ï¼Œå¹¶ä¸”æä¾›ä¸€ä¸ªé”™è¯¯ä¿¡æ¯ç»™åº”ç”¨è½¯ä»¶çš„ç”¨æˆ· （或者采取其他某些相应的操作）。请注意，Hibernate 也有可能抛出其他并不属于 <literal>HibernateException</literal> çš„éžæ£€æŸ¥æœŸå¼‚å¸¸ã€‚è¿™äº›å¼‚å¸¸åŒæ ·ä¹Ÿæ˜¯æ— æ³•æ¢å¤çš„ï¼Œåº”è¯¥ 采取某些相应的操作去处理。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate wraps <literal>SQLException</literal>s thrown while interacting "
-"with the database in a <literal>JDBCException</literal>. In fact, Hibernate "
-"will attempt to convert the exception into a more meaningful subclass of "
-"<literal>JDBCException</literal>. The underlying <literal>SQLException</"
-"literal> is always available via <literal>JDBCException.getCause()</"
-"literal>. Hibernate converts the <literal>SQLException</literal> into an "
-"appropriate <literal>JDBCException</literal> subclass using the "
-"<literal>SQLExceptionConverter</literal> attached to the "
-"<literal>SessionFactory</literal>. By default, the "
-"<literal>SQLExceptionConverter</literal> is defined by the configured "
-"dialect. However, it is also possible to plug in a custom implementation. "
-"See the javadocs for the <literal>SQLExceptionConverterFactory</literal> "
-"class for details. The standard <literal>JDBCException</literal> subtypes "
-"are:"
-msgstr ""
-"在和数据库进行交互时，Hibernate 把捕获的 <literal>SQLException</literal> 封装"
-"为 Hibernate 的  <literal>JDBCException</literal>。事实上，Hibernate 尝试把异"
-"常转换为更有实际含义的 <literal>JDBCException</literal> 异常的子类。底层的 "
-"<literal>SQLException</literal> 可以通过 <literal>JDBCException.getCause()</"
-"literal> 来得到。Hibernate 通过使用关联到  <literal>SessionFactory</literal> "
-"上的 <literal>SQLExceptionConverter</literal> 来把 <literal>SQLException</"
-"literal> 转换为一个对应的 <literal>JDBCException</literal> 异常的子类。默认情"
-"况下，<literal>SQLExceptionConverter</literal> 可以通过配置 dialect 选项指"
-"定；此外，也可以使用用户自定义的实现类（参考 javadocs "
-"<literal>SQLExceptionConverterFactory</literal> ç±»æ¥äº†è§£è¯¦æƒ…ï¼‰ã€‚æ ‡å‡†çš„ "
-"<literal>JDBCException</literal> 子类型是： "
+msgid "Hibernate wraps <literal>SQLException</literal>s thrown while interacting with the database in a <literal>JDBCException</literal>. In fact, Hibernate will attempt to convert the exception into a more meaningful subclass of <literal>JDBCException</literal>. The underlying <literal>SQLException</literal> is always available via <literal>JDBCException.getCause()</literal>. Hibernate converts the <literal>SQLException</literal> into an appropriate <literal>JDBCException</literal> subclass using the <literal>SQLExceptionConverter</literal> attached to the <literal>SessionFactory</literal>. By default, the <literal>SQLExceptionConverter</literal> is defined by the configured dialect. However, it is also possible to plug in a custom implementation. See the javadocs for the <literal>SQLExceptionConverterFactory</literal> class for details. The standard <literal>JDBCException</literal> subtypes are:"
+msgstr "在和数据库进行交互时，Hibernate 把捕获的 <literal>SQLException</literal> 封装为 Hibernate çš„  <literal>JDBCException</literal>。事实上，Hibernate 尝试把异常转换为更有实际含义的 <literal>JDBCException</literal> 异常的子类。底层的 <literal>SQLException</literal> 可以通过 <literal>JDBCException.getCause()</literal> 来得到。Hibernate 通过使用关联到  <literal>SessionFactory</literal> 上的 <literal>SQLExceptionConverter</literal> 来把 <literal>SQLException</literal> 转换为一个对应的 <literal>JDBCException</literal> 异常的子类。默认情况下，<literal>SQLExceptionConverter</literal> 可以通过配置 dialect 选项指定；此外，也可以使用用户自定义的实现类（参考 javadocs <literal>SQLExceptionConverterFactory</literal> ç±»æ¥äº†è§£è¯¦æƒ…ï¼‰ã€‚æ ‡å‡†çš„ <literal>JDBCException</literal> 子类型是： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>JDBCConnectionException</literal>: indicates an error with the "
-"underlying JDBC communication."
-msgstr ""
-"<literal>JDBCConnectionException</literal>：指明底层的 JDBC 通讯出现错误。"
+msgid "<literal>JDBCConnectionException</literal>: indicates an error with the underlying JDBC communication."
+msgstr "<literal>JDBCConnectionException</literal>：指明底层的 JDBC 通讯出现错误。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>SQLGrammarException</literal>: indicates a grammar or syntax "
-"problem with the issued SQL."
-msgstr ""
-"<literal>SQLGrammarException</literal>：指明发送的 SQL è¯­å¥çš„è¯­æ³•æˆ–è€…æ ¼å¼é”™"
-"误。"
+msgid "<literal>SQLGrammarException</literal>: indicates a grammar or syntax problem with the issued SQL."
+msgstr "<literal>SQLGrammarException</literal>：指明发送的 SQL è¯­å¥çš„è¯­æ³•æˆ–è€…æ ¼å¼é”™è¯¯ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>ConstraintViolationException</literal>: indicates some form of "
-"integrity constraint violation."
-msgstr ""
-"<literal>ConstraintViolationException</literal>：指明某种类型的约束违例错误"
+msgid "<literal>ConstraintViolationException</literal>: indicates some form of integrity constraint violation."
+msgstr "<literal>ConstraintViolationException</literal>：指明某种类型的约束违例错误"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>LockAcquisitionException</literal>: indicates an error acquiring a "
-"lock level necessary to perform the requested operation."
-msgstr ""
-"<literal>LockAcquisitionException</literal>：指明了在执行请求操作时，获取所需"
-"的锁级别时出现的错误。"
+msgid "<literal>LockAcquisitionException</literal>: indicates an error acquiring a lock level necessary to perform the requested operation."
+msgstr "<literal>LockAcquisitionException</literal>：指明了在执行请求操作时，获取所需的锁级别时出现的错误。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>GenericJDBCException</literal>: a generic exception which did not "
-"fall into any of the other categories."
-msgstr ""
-"<literal>GenericJDBCException</literal>：不属于任何其他种类的原生异常。"
+msgid "<literal>GenericJDBCException</literal>: a generic exception which did not fall into any of the other categories."
+msgstr "<literal>GenericJDBCException</literal>：不属于任何其他种类的原生异常。"
 
 #. Tag: title
 #, no-c-format
@@ -1016,33 +396,13 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"An important feature provided by a managed environment like EJB, that is "
-"never provided for non-managed code, is transaction timeout. Transaction "
-"timeouts ensure that no misbehaving transaction can indefinitely tie up "
-"resources while returning no response to the user. Outside a managed (JTA) "
-"environment, Hibernate cannot fully provide this functionality. However, "
-"Hibernate can at least control data access operations, ensuring that "
-"database level deadlocks and queries with huge result sets are limited by a "
-"defined timeout. In a managed environment, Hibernate can delegate "
-"transaction timeout to JTA. This functionality is abstracted by the "
-"Hibernate <literal>Transaction</literal> object."
-msgstr ""
-"EJB è¿™æ ·çš„æ‰˜ç®¡çŽ¯å¢ƒæœ‰ä¸€é¡¹æžä¸ºé‡è¦çš„ç‰¹æ€§ï¼Œè€Œå®ƒä»Žæœªåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸­æä¾›è¿‡ï¼Œé‚£å°±æ˜¯"
-"äº‹åŠ¡è¶…æ—¶ã€‚åœ¨å‡ºçŽ°é”™è¯¯çš„äº‹åŠ¡è¡Œä¸ºçš„æ—¶å€™ï¼Œè¶…æ—¶å¯ä»¥ç¡®ä¿ä¸ä¼šæ— é™æŒ‚èµ·èµ„æºã€å¯¹ç”¨æˆ·æ²¡"
-"有交代。在托管（JTA）环境之外，Hibernate æ— æ³•å®Œå…¨æä¾›è¿™ä¸€åŠŸèƒ½ã€‚ä½†æ˜¯ï¼Œ"
-"Hiberante 至少可以控制数据访问，确保数据库级别的死锁，和返回巨大结果集的查询"
-"被限定在一个规定的时间内。在托管环境中，Hibernate 会把事务超时转交给 JTA。这"
-"一功能通过 Hibernate <literal>Transaction</literal> 对象进行抽象。 "
+msgid "An important feature provided by a managed environment like EJB, that is never provided for non-managed code, is transaction timeout. Transaction timeouts ensure that no misbehaving transaction can indefinitely tie up resources while returning no response to the user. Outside a managed (JTA) environment, Hibernate cannot fully provide this functionality. However, Hibernate can at least control data access operations, ensuring that database level deadlocks and queries with huge result sets are limited by a defined timeout. In a managed environment, Hibernate can delegate transaction timeout to JTA. This functionality is abstracted by the Hibernate <literal>Transaction</literal> object."
+msgstr "EJB è¿™æ ·çš„æ‰˜ç®¡çŽ¯å¢ƒæœ‰ä¸€é¡¹æžä¸ºé‡è¦çš„ç‰¹æ€§ï¼Œè€Œå®ƒä»Žæœªåœ¨éžæ‰˜ç®¡çŽ¯å¢ƒä¸­æä¾›è¿‡ï¼Œé‚£å°±æ˜¯äº‹åŠ¡è¶…æ—¶ã€‚åœ¨å‡ºçŽ°é”™è¯¯çš„äº‹åŠ¡è¡Œä¸ºçš„æ—¶å€™ï¼Œè¶…æ—¶å¯ä»¥ç¡®ä¿ä¸ä¼šæ— é™æŒ‚èµ·èµ„æºã€å¯¹ç”¨æˆ·æ²¡æœ‰äº¤ä»£ã€‚åœ¨æ‰˜ç®¡ï¼ˆJTA）环境之外，Hibernate æ— æ³•å®Œå…¨æä¾›è¿™ä¸€åŠŸèƒ½ã€‚ä½†æ˜¯ï¼ŒHiberante 至少可以控制数据访问，确保数据库级别的死锁，和返回巨大结果集的查询被限定在一个规定的时间内。在托管环境中，Hibernate 会把事务超时转交给 JTA。这一功能通过 Hibernate <literal>Transaction</literal> 对象进行抽象。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>setTimeout()</literal> cannot be called in a CMT bean, where "
-"transaction timeouts must be defined declaratively."
-msgstr ""
-"注意 <literal>setTimeout()</literal> 不应该在 CMT bean 中调用，此时事务超时值"
-"应该是被声明式定义的。 "
+msgid "<literal>setTimeout()</literal> cannot be called in a CMT bean, where transaction timeouts must be defined declaratively."
+msgstr "注意 <literal>setTimeout()</literal> 不应该在 CMT bean 中调用，此时事务超时值应该是被声明式定义的。 "
 
 #. Tag: title
 #, no-c-format
@@ -1051,20 +411,8 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The only approach that is consistent with high concurrency and high "
-"scalability, is optimistic concurrency control with versioning. Version "
-"checking uses version numbers, or timestamps, to detect conflicting updates "
-"and to prevent lost updates. Hibernate provides three possible approaches to "
-"writing application code that uses optimistic concurrency. The use cases we "
-"discuss are in the context of long conversations, but version checking also "
-"has the benefit of preventing lost updates in single database transactions."
-msgstr ""
-"唯一能够同时保持高并发和高可伸缩性的方法就是使用带版本化的乐观并发控制。版本"
-"检查使用版本号、 或者时间戳来检测更新冲突（并且防止更新丢失）。Hibernate 为使"
-"ç”¨ä¹è§‚å¹¶å‘æŽ§åˆ¶çš„ä»£ç æä¾›äº†ä¸‰ç§å¯ èƒ½çš„æ–¹æ³•ï¼Œåº”ç”¨ç¨‹åºåœ¨ç¼–å†™è¿™äº›ä»£ç æ—¶ï¼Œå¯ä»¥é‡‡ç”¨"
-"它们。我们已经在前面应用程序对话那部分展示了 乐观并发控制的应用场景，此外，在"
-"单个数据库事务范围内，版本检查也提供了防止更新丢失的好处。 "
+msgid "The only approach that is consistent with high concurrency and high scalability, is optimistic concurrency control with versioning. Version checking uses version numbers, or timestamps, to detect conflicting updates and to prevent lost updates. Hibernate provides three possible approaches to writing application code that uses optimistic concurrency. The use cases we discuss are in the context of long conversations, but version checking also has the benefit of preventing lost updates in single database transactions."
+msgstr "唯一能够同时保持高并发和高可伸缩性的方法就是使用带版本化的乐观并发控制。版本检查使用版本号、 或者时间戳来检测更新冲突（并且防止更新丢失）。Hibernate ä¸ºä½¿ç”¨ä¹è§‚å¹¶å‘æŽ§åˆ¶çš„ä»£ç æä¾›äº†ä¸‰ç§å¯ èƒ½çš„æ–¹æ³•ï¼Œåº”ç”¨ç¨‹åºåœ¨ç¼–å†™è¿™äº›ä»£ç æ—¶ï¼Œå¯ä»¥é‡‡ç”¨å®ƒä»¬ã€‚æˆ‘ä»¬å·²ç»åœ¨å‰é¢åº”ç”¨ç¨‹åºå¯¹è¯é‚£éƒ¨åˆ†å±•ç¤ºäº† 乐观并发控制的应用场景，此外，在单个数据库事务范围内，版本检查也提供了防止更新丢失的好处。 "
 
 #. Tag: title
 #, no-c-format
@@ -1073,60 +421,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In an implementation without much help from Hibernate, each interaction with "
-"the database occurs in a new <literal>Session</literal> and the developer is "
-"responsible for reloading all persistent instances from the database before "
-"manipulating them. The application is forced to carry out its own version "
-"checking to ensure conversation transaction isolation. This approach is the "
-"least efficient in terms of database access. It is the approach most similar "
-"to entity EJBs."
-msgstr ""
-"未能充分利用 Hibernate åŠŸèƒ½çš„å®žçŽ°ä»£ç ä¸­ï¼Œæ¯æ¬¡å’Œæ•°æ®åº“äº¤äº’éƒ½éœ€è¦ä¸€ä¸ªæ–°çš„  "
-"<literal>Session</literal>，而且开发人员必须在显示数据之前从数据库中重新载入"
-"所有的持久化对象实例。这种方式迫使应用程序自己实现版本检查来确保对话事务的隔"
-"离，从数据访问的角度来说是最低效的。这种使用方式和 entity EJB 最相似。 "
+msgid "In an implementation without much help from Hibernate, each interaction with the database occurs in a new <literal>Session</literal> and the developer is responsible for reloading all persistent instances from the database before manipulating them. The application is forced to carry out its own version checking to ensure conversation transaction isolation. This approach is the least efficient in terms of database access. It is the approach most similar to entity EJBs."
+msgstr "未能充分利用 Hibernate åŠŸèƒ½çš„å®žçŽ°ä»£ç ä¸­ï¼Œæ¯æ¬¡å’Œæ•°æ®åº“äº¤äº’éƒ½éœ€è¦ä¸€ä¸ªæ–°çš„  <literal>Session</literal>，而且开发人员必须在显示数据之前从数据库中重新载入所有的持久化对象实例。这种方式迫使应用程序自己实现版本检查来确保对话事务的隔离，从数据访问的角度来说是最低效的。这种使用方式和 entity EJB 最相似。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>version</literal> property is mapped using <literal>&lt;"
-"version&gt;</literal>, and Hibernate will automatically increment it during "
-"flush if the entity is dirty."
-msgstr ""
-"<literal>version</literal> 属性使用 <literal>&lt;version&gt;</literal> æ¥æ˜ "
-"射，如果对象是脏数据，在同步的时候，Hibernate ä¼šè‡ªåŠ¨å¢žåŠ ç‰ˆæœ¬å·ã€‚"
+msgid "The <literal>version</literal> property is mapped using <literal>&lt;version&gt;</literal>, and Hibernate will automatically increment it during flush if the entity is dirty."
+msgstr "<literal>version</literal> 属性使用 <literal>&lt;version&gt;</literal> æ¥æ˜ å°„ï¼Œå¦‚æžœå¯¹è±¡æ˜¯è„æ•°æ®ï¼Œåœ¨åŒæ­¥çš„æ—¶å€™ï¼ŒHibernate ä¼šè‡ªåŠ¨å¢žåŠ ç‰ˆæœ¬å·ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If you are operating in a low-data-concurrency environment, and do not "
-"require version checking, you can use this approach and skip the version "
-"check. In this case, <emphasis>last commit wins</emphasis> is the default "
-"strategy for long conversations. Be aware that this might confuse the users "
-"of the application, as they might experience lost updates without error "
-"messages or a chance to merge conflicting changes."
-msgstr ""
-"å½“ç„¶ï¼Œå¦‚æžœä½ çš„åº”ç”¨æ˜¯åœ¨ä¸€ä¸ªä½Žæ•°æ®å¹¶å‘çŽ¯å¢ƒä¸‹ï¼Œå¹¶ä¸éœ€è¦ç‰ˆæœ¬æ£€æŸ¥çš„è¯ï¼Œä½ ç…§æ ·å¯ä»¥"
-"使用这种方式，只不过跳过版本检查就是了。在这种情况下，<emphasis>最晚提交生效"
-"</emphasis> （<emphasis>last commit wins</emphasis>ï¼‰å°±æ˜¯ä½ çš„é•¿å¯¹è¯çš„é»˜è®¤å¤„ç†"
-"ç­–ç•¥ã€‚è¯·è®°ä½è¿™ç§ç­–ç•¥å¯èƒ½ä¼šè®©åº”ç”¨è½¯ä»¶çš„ç”¨æˆ·æ„Ÿåˆ°å›°æƒ‘ï¼Œå› ä¸ºä»–ä»¬æœ‰å¯èƒ½ä¼šç¢°ä¸Šæ›´æ–°"
-"丢失掉却没有出错信息，或者需要合并更改冲突的情况。 "
+msgid "If you are operating in a low-data-concurrency environment, and do not require version checking, you can use this approach and skip the version check. In this case, <emphasis>last commit wins</emphasis> is the default strategy for long conversations. Be aware that this might confuse the users of the application, as they might experience lost updates without error messages or a chance to merge conflicting changes."
+msgstr "å½“ç„¶ï¼Œå¦‚æžœä½ çš„åº”ç”¨æ˜¯åœ¨ä¸€ä¸ªä½Žæ•°æ®å¹¶å‘çŽ¯å¢ƒä¸‹ï¼Œå¹¶ä¸éœ€è¦ç‰ˆæœ¬æ£€æŸ¥çš„è¯ï¼Œä½ ç…§æ ·å¯ä»¥ä½¿ç”¨è¿™ç§æ–¹å¼ï¼Œåªä¸è¿‡è·³è¿‡ç‰ˆæœ¬æ£€æŸ¥å°±æ˜¯äº†ã€‚åœ¨è¿™ç§æƒ…å†µä¸‹ï¼Œ<emphasis>最晚提交生效</emphasis> （<emphasis>last commit wins</emphasis>ï¼‰å°±æ˜¯ä½ çš„é•¿å¯¹è¯çš„é»˜è®¤å¤„ç†ç­–ç•¥ã€‚è¯·è®°ä½è¿™ç§ç­–ç•¥å¯èƒ½ä¼šè®©åº”ç”¨è½¯ä»¶çš„ç”¨æˆ·æ„Ÿåˆ°å›°æƒ‘ï¼Œå› ä¸ºä»–ä»¬æœ‰å¯èƒ½ä¼šç¢°ä¸Šæ›´æ–°ä¸¢å¤±æŽ‰å´æ²¡æœ‰å‡ºé”™ä¿¡æ¯ï¼Œæˆ–è€…éœ€è¦åˆå¹¶æ›´æ”¹å†²çªçš„æƒ…å†µã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Manual version checking is only feasible in trivial circumstances and not "
-"practical for most applications. Often not only single instances, but "
-"complete graphs of modified objects, have to be checked. Hibernate offers "
-"automatic version checking with either an extended <literal>Session</"
-"literal> or detached instances as the design paradigm."
-msgstr ""
-"很明显，手工进行版本检查只适合于某些软件规模非常小的应用场景，对于大多数软件"
-"应用场景来说并不现实。通常情况下，不仅是单个对象实例需要进行版本检查，整个被"
-"ä¿®æ”¹è¿‡çš„å…³è”å¯¹è±¡å›¾ä¹Ÿéƒ½éœ€è¦è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥ã€‚ä½œä¸ºæ ‡å‡†è®¾è®¡èŒƒä¾‹ï¼ŒHibernate 使用扩展"
-"周期的 <literal>Session</literal> 的方式，或者脱管对象实例的方式来提供自动版"
-"本检查。 "
+msgid "Manual version checking is only feasible in trivial circumstances and not practical for most applications. Often not only single instances, but complete graphs of modified objects, have to be checked. Hibernate offers automatic version checking with either an extended <literal>Session</literal> or detached instances as the design paradigm."
+msgstr "å¾ˆæ˜Žæ˜¾ï¼Œæ‰‹å·¥è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥åªé€‚åˆäºŽæŸäº›è½¯ä»¶è§„æ¨¡éžå¸¸å°çš„åº”ç”¨åœºæ™¯ï¼Œå¯¹äºŽå¤§å¤šæ•°è½¯ä»¶åº”ç”¨åœºæ™¯æ¥è¯´å¹¶ä¸çŽ°å®žã€‚é€šå¸¸æƒ…å†µä¸‹ï¼Œä¸ä»…æ˜¯å•ä¸ªå¯¹è±¡å®žä¾‹éœ€è¦è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥ï¼Œæ•´ä¸ªè¢«ä¿®æ”¹è¿‡çš„å…³è”å¯¹è±¡å›¾ä¹Ÿéƒ½éœ€è¦è¿›è¡Œç‰ˆæœ¬æ£€æŸ¥ã€‚ä½œä¸ºæ ‡å‡†è®¾è®¡èŒƒä¾‹ï¼ŒHibernate 使用扩展周期的 <literal>Session</literal> 的方式，或者脱管对象实例的方式来提供自动版本检查。 "
 
 #. Tag: title
 #, no-c-format
@@ -1135,80 +446,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A single <literal>Session</literal> instance and its persistent instances "
-"that are used for the whole conversation are known as <emphasis>session-per-"
-"conversation</emphasis>. Hibernate checks instance versions at flush time, "
-"throwing an exception if concurrent modification is detected. It is up to "
-"the developer to catch and handle this exception. Common options are the "
-"opportunity for the user to merge changes or to restart the business "
-"conversation with non-stale data."
-msgstr ""
-"单个 <literal>Session</literal> 实例和它所关联的所有持久化对象实例都被用于整"
-"个对话，这被称为 <emphasis>session-per-conversation</emphasis>。Hibernate 在"
-"同步的时候进行对象实例的版本检查，如果检测到并发修改则抛出异常。由开发人员来"
-"决定是否需要捕获和处理这个异常（通常的抉择是给用户 æä¾›ä¸€ä¸ªåˆå¹¶æ›´æ”¹ï¼Œæˆ–è€…åœ¨æ— "
-"脏数据情况下重新进行业务对话的机会）。 "
+msgid "A single <literal>Session</literal> instance and its persistent instances that are used for the whole conversation are known as <emphasis>session-per-conversation</emphasis>. Hibernate checks instance versions at flush time, throwing an exception if concurrent modification is detected. It is up to the developer to catch and handle this exception. Common options are the opportunity for the user to merge changes or to restart the business conversation with non-stale data."
+msgstr "单个 <literal>Session</literal> 实例和它所关联的所有持久化对象实例都被用于整个对话，这被称为 <emphasis>session-per-conversation</emphasis>。Hibernate 在同步的时候进行对象实例的版本检查，如果检测到并发修改则抛出异常。由开发人员来决定是否需要捕获和处理这个异常（通常的抉择是给用户 æä¾›ä¸€ä¸ªåˆå¹¶æ›´æ”¹ï¼Œæˆ–è€…åœ¨æ— è„æ•°æ®æƒ…å†µä¸‹é‡æ–°è¿›è¡Œä¸šåŠ¡å¯¹è¯çš„æœºä¼šï¼‰ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>Session</literal> is disconnected from any underlying JDBC "
-"connection when waiting for user interaction. This approach is the most "
-"efficient in terms of database access. The application does not version "
-"check or reattach detached instances, nor does it have to reload instances "
-"in every database transaction."
-msgstr ""
-"在等待用户交互的时候， <literal>Session</literal> 断开底层的 JDBC 连接。这种"
-"方式以数据库访问的角度来说是最高效的方式。应用程序不需要关心版本检查或脱管对"
-"象实例的重新关联，在每个数据库事务中，应用程序也不需要载入读取对象实例。 "
+msgid "The <literal>Session</literal> is disconnected from any underlying JDBC connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application does not version check or reattach detached instances, nor does it have to reload instances in every database transaction."
+msgstr "在等待用户交互的时候， <literal>Session</literal> 断开底层的 JDBC 连接。这种方式以数据库访问的角度来说是最高效的方式。应用程序不需要关心版本检查或脱管对象实例的重新关联，在每个数据库事务中，应用程序也不需要载入读取对象实例。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>foo</literal> object knows which <literal>Session</literal> it "
-"was loaded in. Beginning a new database transaction on an old session "
-"obtains a new connection and resumes the session. Committing a database "
-"transaction disconnects a session from the JDBC connection and returns the "
-"connection to the pool. After reconnection, to force a version check on data "
-"you are not updating, you can call <literal>Session.lock()</literal> with "
-"<literal>LockMode.READ</literal> on any objects that might have been updated "
-"by another transaction. You do not need to lock any data that you "
-"<emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode."
-"MANUAL</literal> on an extended <literal>Session</literal>, so that only the "
-"last database transaction cycle is allowed to actually persist all "
-"modifications made in this conversation. Only this last database transaction "
-"will include the <literal>flush()</literal> operation, and then "
-"<literal>close()</literal> the session to end the conversation."
-msgstr ""
-"<literal>foo</literal> 对象知道它是在哪个 <literal>Session</literal> 中被装入"
-"的。在一个旧 session 中开启一个新的数据库事务，会导致 session 获取一个新的连"
-"接，并恢复 session 的功能。将数据库事务提交，使得 session 从 JDBC 连接断开，"
-"å¹¶å°†æ­¤è¿žæŽ¥äº¤è¿˜ç»™è¿žæŽ¥æ± ã€‚åœ¨é‡æ–°è¿žæŽ¥ä¹‹åŽï¼Œè¦å¼ºåˆ¶å¯¹ä½ æ²¡æœ‰æ›´æ–°çš„æ•°æ®è¿›è¡Œä¸€æ¬¡ç‰ˆæœ¬"
-"æ£€æŸ¥ï¼Œä½ å¯ä»¥å¯¹æ‰€æœ‰å¯èƒ½è¢«å…¶ä»–äº‹åŠ¡ä¿®æ”¹è¿‡çš„å¯¹è±¡ï¼Œä½¿ç”¨å‚æ•° <literal>LockMode."
-"READ</literal> 来调用 <literal>Session.lock()</literal>ã€‚ä½ ä¸ç”¨ lock ä»»ä½•ä½ "
-"<emphasis>正在</emphasis>æ›´æ–°çš„æ•°æ®ã€‚ä¸€èˆ¬ä½ ä¼šåœ¨æ‰©å±•çš„ <literal>Session</"
-"literal> 上设置 <literal>FlushMode.NEVER</literal>ï¼Œå› æ­¤åªæœ‰æœ€åŽä¸€ä¸ªæ•°æ®åº“äº‹"
-"åŠ¡å¾ªçŽ¯æ‰ä¼šçœŸæ­£çš„æŠŠæ•´ä¸ªå¯¹è¯ä¸­å‘ç”Ÿçš„ä¿®æ”¹å‘é€åˆ°æ•°æ®åº“ã€‚å› æ­¤ï¼Œåªæœ‰è¿™æœ€åŽä¸€æ¬¡æ•°æ®"
-"库事务才会包含 <literal>flush()</literal> 操作，然后在整个对话结束后，还要 "
-"<literal>close()</literal> 这个 session。 "
+msgid "The <literal>foo</literal> object knows which <literal>Session</literal> it was loaded in. Beginning a new database transaction on an old session obtains a new connection and resumes the session. Committing a database transaction disconnects a session from the JDBC connection and returns the connection to the pool. After reconnection, to force a version check on data you are not updating, you can call <literal>Session.lock()</literal> with <literal>LockMode.READ</literal> on any objects that might have been updated by another transaction. You do not need to lock any data that you <emphasis>are</emphasis> updating. Usually you would set <literal>FlushMode.MANUAL</literal> on an extended <literal>Session</literal>, so that only the last database transaction cycle is allowed to actually persist all modifications made in this conversation. Only this last database transaction will include the <literal>flush()</literal> operation, and then <literal>close()</literal> the se!
 ssion to end the conversation."
+msgstr "<literal>foo</literal> 对象知道它是在哪个 <literal>Session</literal> 中被装入的。在一个旧 session 中开启一个新的数据库事务，会导致 session 获取一个新的连接，并恢复 session 的功能。将数据库事务提交，使得 session 从 JDBC è¿žæŽ¥æ–­å¼€ï¼Œå¹¶å°†æ­¤è¿žæŽ¥äº¤è¿˜ç»™è¿žæŽ¥æ± ã€‚åœ¨é‡æ–°è¿žæŽ¥ä¹‹åŽï¼Œè¦å¼ºåˆ¶å¯¹ä½ æ²¡æœ‰æ›´æ–°çš„æ•°æ®è¿›è¡Œä¸€æ¬¡ç‰ˆæœ¬æ£€æŸ¥ï¼Œä½ å¯ä»¥å¯¹æ‰€æœ‰å¯èƒ½è¢«å…¶ä»–äº‹åŠ¡ä¿®æ”¹è¿‡çš„å¯¹è±¡ï¼Œä½¿ç”¨å‚æ•° <literal>LockMode.READ</literal> 来调用 <literal>Session.lock()</literal>ã€‚ä½ ä¸ç”¨ lock ä»»ä½•ä½ <emphasis>正在</emphasis>æ›´æ–°çš„æ•°æ®ã€‚ä¸€èˆ¬ä½ ä¼šåœ¨æ‰©å±•çš„ <literal>Session</literal> 上设置 <literal>FlushMode.NEVER</literal>ï¼Œå› æ­¤åªæœ‰æœ€åŽä¸€ä¸ªæ•°æ®åº“äº‹åŠ¡å¾ªçŽ¯æ‰ä¼šçœŸæ­£çš„æŠŠæ•´ä¸ªå¯¹è¯ä¸­å‘ç”Ÿçš„ä¿®æ”¹å‘é€åˆ°æ•°æ®åº“ã€‚å› æ­¤ï¼Œåªæœ‰è¿™æœ€åŽä¸€æ¬¡æ•°æ®åº“äº‹åŠ¡æ‰ä¼šåŒ…å« <literal>flush()</literal> 操作，然后在整个对话结束后ï¼!
 Œè¿˜è¦ <literal>close()</literal> 这个 session。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"This pattern is problematic if the <literal>Session</literal> is too big to "
-"be stored during user think time (for example, an <literal>HttpSession</"
-"literal> should be kept as small as possible). As the <literal>Session</"
-"literal> is also the first-level cache and contains all loaded objects, we "
-"can probably use this strategy only for a few request/response cycles. Use a "
-"<literal>Session</literal> only for a single conversation as it will soon "
-"have stale data."
-msgstr ""
-"如果在用户思考的过程中，<literal>Session</literal> å› ä¸ºå¤ªå¤§äº†è€Œä¸èƒ½ä¿å­˜ï¼Œé‚£ä¹ˆ"
-"这种模式是有问题的。举例来说，一个 <literal>HttpSession</literal> 应该尽可能"
-"的小。由于  <literal>Session</literal> 是一级缓存，并且保持了所有被载入过的对"
-"è±¡ï¼Œå› æ­¤æˆ‘ä»¬åªåº”è¯¥åœ¨é‚£äº›å°‘é‡çš„ request/response æƒ…å†µä¸‹ä½¿ç”¨è¿™ç§ç­–ç•¥ã€‚ä½ åº”è¯¥åª"
-"把一个 <literal>Session</literal> ç”¨äºŽå•ä¸ªå¯¹è¯ï¼Œå› ä¸ºå®ƒå¾ˆå¿«å°±ä¼šå‡ºçŽ°è„æ•°æ®ã€‚ "
+msgid "This pattern is problematic if the <literal>Session</literal> is too big to be stored during user think time (for example, an <literal>HttpSession</literal> should be kept as small as possible). As the <literal>Session</literal> is also the first-level cache and contains all loaded objects, we can probably use this strategy only for a few request/response cycles. Use a <literal>Session</literal> only for a single conversation as it will soon have stale data."
+msgstr "如果在用户思考的过程中，<literal>Session</literal> å› ä¸ºå¤ªå¤§äº†è€Œä¸èƒ½ä¿å­˜ï¼Œé‚£ä¹ˆè¿™ç§æ¨¡å¼æ˜¯æœ‰é—®é¢˜çš„ã€‚ä¸¾ä¾‹æ¥è¯´ï¼Œä¸€ä¸ª <literal>HttpSession</literal> 应该尽可能的小。由于  <literal>Session</literal> æ˜¯ä¸€çº§ç¼“å­˜ï¼Œå¹¶ä¸”ä¿æŒäº†æ‰€æœ‰è¢«è½½å…¥è¿‡çš„å¯¹è±¡ï¼Œå› æ­¤æˆ‘ä»¬åªåº”è¯¥åœ¨é‚£äº›å°‘é‡çš„ request/response æƒ…å†µä¸‹ä½¿ç”¨è¿™ç§ç­–ç•¥ã€‚ä½ åº”è¯¥åªæŠŠä¸€ä¸ª <literal>Session</literal> ç”¨äºŽå•ä¸ªå¯¹è¯ï¼Œå› ä¸ºå®ƒå¾ˆå¿«å°±ä¼šå‡ºçŽ°è„æ•°æ®ã€‚ "
 
 #. Tag: title
 #, no-c-format
@@ -1217,42 +471,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Earlier versions of Hibernate required explicit disconnection and "
-"reconnection of a <literal>Session</literal>. These methods are deprecated, "
-"as beginning and ending a transaction has the same effect."
-msgstr ""
-"注意，早期的 Hibernate 版本需要明确的对 <literal>Session</literal> 进行 "
-"disconnect å’Œ reconnectã€‚è¿™äº›æ–¹æ³•çŽ°åœ¨å·²ç»è¿‡æ—¶äº†ï¼Œæ‰“å¼€äº‹åŠ¡å’Œå…³é—­äº‹åŠ¡ä¼šèµ·åˆ°åŒæ ·"
-"的效果。"
+msgid "Earlier versions of Hibernate required explicit disconnection and reconnection of a <literal>Session</literal>. These methods are deprecated, as beginning and ending a transaction has the same effect."
+msgstr "注意，早期的 Hibernate 版本需要明确的对 <literal>Session</literal> 进行 disconnect å’Œ reconnectã€‚è¿™äº›æ–¹æ³•çŽ°åœ¨å·²ç»è¿‡æ—¶äº†ï¼Œæ‰“å¼€äº‹åŠ¡å’Œå…³é—­äº‹åŠ¡ä¼šèµ·åˆ°åŒæ ·çš„æ•ˆæžœã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Keep the disconnected <literal>Session</literal> close to the persistence "
-"layer. Use an EJB stateful session bean to hold the <literal>Session</"
-"literal> in a three-tier environment. Do not transfer it to the web layer, "
-"or even serialize it to a separate tier, to store it in the "
-"<literal>HttpSession</literal>."
-msgstr ""
-"æ­¤å¤–ï¼Œä¹Ÿè¯·æ³¨æ„ï¼Œä½ åº”è¯¥è®©ä¸Žæ•°æ®åº“è¿žæŽ¥æ–­å¼€çš„ <literal>Session</literal> 对持久"
-"层保持关闭状态。换句话说，在三层环境中，使用有状态的 EJB session bean 来持 有"
-"<literal>Session</literal>， è€Œä¸è¦æŠŠå®ƒä¼ é€’åˆ° web 层（甚至把它序列化到一个单"
-"独的层），保存在 <literal>HttpSession</literal> 中。 "
+msgid "Keep the disconnected <literal>Session</literal> close to the persistence layer. Use an EJB stateful session bean to hold the <literal>Session</literal> in a three-tier environment. Do not transfer it to the web layer, or even serialize it to a separate tier, to store it in the <literal>HttpSession</literal>."
+msgstr "æ­¤å¤–ï¼Œä¹Ÿè¯·æ³¨æ„ï¼Œä½ åº”è¯¥è®©ä¸Žæ•°æ®åº“è¿žæŽ¥æ–­å¼€çš„ <literal>Session</literal> 对持久层保持关闭状态。换句话说，在三层环境中，使用有状态的 EJB session bean 来持 有<literal>Session</literal>， è€Œä¸è¦æŠŠå®ƒä¼ é€’åˆ° web 层（甚至把它序列化到一个单独的层），保存在 <literal>HttpSession</literal> 中。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The extended session pattern, or <emphasis>session-per-conversation</"
-"emphasis>, is more difficult to implement with automatic current session "
-"context management. You need to supply your own implementation of the "
-"<literal>CurrentSessionContext</literal> for this. See the Hibernate Wiki "
-"for examples."
-msgstr ""
-"扩展 session 模式，或者被称为<emphasis>每次对话一个session（session-per-"
-"conversation）</emphasis>，自动管理当前 session ä¸Šä¸‹æ–‡è”ç”¨çš„æ—¶å€™ä¼šæ›´å›°éš¾ã€‚ä½ "
-"éœ€è¦æä¾›ä½ è‡ªå·±çš„ <literal>CurrentSessionContext</literal> 实现。请参阅 "
-"Hibernate Wiki 以获得示例。 "
+msgid "The extended session pattern, or <emphasis>session-per-conversation</emphasis>, is more difficult to implement with automatic current session context management. You need to supply your own implementation of the <literal>CurrentSessionContext</literal> for this. See the Hibernate Wiki for examples."
+msgstr "扩展 session 模式，或者被称为<emphasis>每次对话一个session（session-per-conversation）</emphasis>，自动管理当前 session ä¸Šä¸‹æ–‡è”ç”¨çš„æ—¶å€™ä¼šæ›´å›°éš¾ã€‚ä½ éœ€è¦æä¾›ä½ è‡ªå·±çš„ <literal>CurrentSessionContext</literal> 实现。请参阅 Hibernate Wiki 以获得示例。 "
 
 #. Tag: title
 #, no-c-format
@@ -1261,42 +491,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Each interaction with the persistent store occurs in a new <literal>Session</"
-"literal>. However, the same persistent instances are reused for each "
-"interaction with the database. The application manipulates the state of "
-"detached instances originally loaded in another <literal>Session</literal> "
-"and then reattaches them using <literal>Session.update()</literal>, "
-"<literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</"
-"literal>."
-msgstr ""
-"这种方式下，与持久化存储的每次交互都发生在一个新的 <literal>Session</"
-"literal> 中。然而，同一持久化对象实例可以在多次与数据库的交互中重用。应用程序"
-"操纵脱管对象实例 的状态，这个脱管对象实例最初是在另一个 <literal>Session</"
-"literal> 中载入的，然后调用 <literal>Session.update()</literal>，"
-"<literal>Session.saveOrUpdate()</literal>，或者  <literal>Session.merge()</"
-"literal> 来重新关联该对象实例。"
+msgid "Each interaction with the persistent store occurs in a new <literal>Session</literal>. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another <literal>Session</literal> and then reattaches them using <literal>Session.update()</literal>, <literal>Session.saveOrUpdate()</literal>, or <literal>Session.merge()</literal>."
+msgstr "这种方式下，与持久化存储的每次交互都发生在一个新的 <literal>Session</literal> 中。然而，同一持久化对象实例可以在多次与数据库的交互中重用。应用程序操纵脱管对象实例 的状态，这个脱管对象实例最初是在另一个 <literal>Session</literal> 中载入的，然后调用 <literal>Session.update()</literal>，<literal>Session.saveOrUpdate()</literal>，或者  <literal>Session.merge()</literal> 来重新关联该对象实例。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Again, Hibernate will check instance versions during flush, throwing an "
-"exception if conflicting updates occurred."
-msgstr ""
-"Hibernate 会再一次在同步的时候检查对象实例的版本，如果发生更新冲突，就抛出异"
-"常。 "
+msgid "Again, Hibernate will check instance versions during flush, throwing an exception if conflicting updates occurred."
+msgstr "Hibernate 会再一次在同步的时候检查对象实例的版本，如果发生更新冲突，就抛出异常。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can also call <literal>lock()</literal> instead of <literal>update()</"
-"literal>, and use <literal>LockMode.READ</literal> (performing a version "
-"check and bypassing all caches) if you are sure that the object has not been "
-"modified."
-msgstr ""
-"å¦‚æžœä½ ç¡®ä¿¡å¯¹è±¡æ²¡æœ‰è¢«ä¿®æ”¹è¿‡ï¼Œä½ ä¹Ÿå¯ä»¥è°ƒç”¨ <literal>lock()</literal> 来设置  "
-"<literal>LockMode.READ</literal>（绕过所有的缓存，执行版本检查），从而取代  "
-"<literal>update()</literal> 操作。 "
+msgid "You can also call <literal>lock()</literal> instead of <literal>update()</literal>, and use <literal>LockMode.READ</literal> (performing a version check and bypassing all caches) if you are sure that the object has not been modified."
+msgstr "å¦‚æžœä½ ç¡®ä¿¡å¯¹è±¡æ²¡æœ‰è¢«ä¿®æ”¹è¿‡ï¼Œä½ ä¹Ÿå¯ä»¥è°ƒç”¨ <literal>lock()</literal> 来设置  <literal>LockMode.READ</literal>（绕过所有的缓存，执行版本检查），从而取代  <literal>update()</literal> 操作。 "
 
 #. Tag: title
 #, no-c-format
@@ -1305,77 +511,23 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"You can disable Hibernate's automatic version increment for particular "
-"properties and collections by setting the <literal>optimistic-lock</literal> "
-"mapping attribute to <literal>false</literal>. Hibernate will then no longer "
-"increment versions if the property is dirty."
-msgstr ""
-"å¯¹äºŽç‰¹å®šçš„å±žæ€§å’Œé›†åˆï¼Œé€šè¿‡ä¸ºå®ƒä»¬è®¾ç½®æ˜ å°„å±žæ€§ <literal>optimistic-lock</"
-"literal> 的值为 <literal>false</literal>，来禁止 Hibernate çš„ç‰ˆæœ¬è‡ªåŠ¨å¢žåŠ ã€‚è¿™"
-"æ ·çš„è¯ï¼Œå¦‚æžœè¯¥å±žæ€§è„æ•°æ®ï¼ŒHibernate å°†ä¸å†å¢žåŠ ç‰ˆæœ¬å·ã€‚ "
+msgid "You can disable Hibernate's automatic version increment for particular properties and collections by setting the <literal>optimistic-lock</literal> mapping attribute to <literal>false</literal>. Hibernate will then no longer increment versions if the property is dirty."
+msgstr "å¯¹äºŽç‰¹å®šçš„å±žæ€§å’Œé›†åˆï¼Œé€šè¿‡ä¸ºå®ƒä»¬è®¾ç½®æ˜ å°„å±žæ€§ <literal>optimistic-lock</literal> 的值为 <literal>false</literal>，来禁止 Hibernate çš„ç‰ˆæœ¬è‡ªåŠ¨å¢žåŠ ã€‚è¿™æ ·çš„è¯ï¼Œå¦‚æžœè¯¥å±žæ€§è„æ•°æ®ï¼ŒHibernate å°†ä¸å†å¢žåŠ ç‰ˆæœ¬å·ã€‚ "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Legacy database schemas are often static and cannot be modified. Or, other "
-"applications might access the same database and will not know how to handle "
-"version numbers or even timestamps. In both cases, versioning cannot rely on "
-"a particular column in a table. To force a version check with a comparison "
-"of the state of all fields in a row but without a version or timestamp "
-"property mapping, turn on <literal>optimistic-lock=\"all\"</literal> in the "
-"<literal>&lt;class&gt;</literal> mapping. This conceptually only works if "
-"Hibernate can compare the old and the new state (i.e., if you use a single "
-"long <literal>Session</literal> and not session-per-request-with-detached-"
-"objects)."
-msgstr ""
-"遗留系统的数据库 Schema 通常是静态的，不可修改的。或者，其他应用程序也可能访"
-"é—®åŒä¸€æ•°æ®åº“ï¼Œæ ¹æœ¬æ— æ³•å¾—çŸ¥å¦‚ä½•å¤„ç†ç‰ˆæœ¬å·ï¼Œç”šè‡³æ—¶é—´æˆ³ã€‚åœ¨ä»¥ä¸Šçš„æ‰€æœ‰åœºæ™¯ä¸­ï¼Œå®ž"
-"çŽ°ç‰ˆæœ¬åŒ–ä¸èƒ½ä¾é æ•°æ®åº“è¡¨çš„æŸä¸ªç‰¹å®šåˆ—ã€‚åœ¨ <literal>&lt;class&gt;</literal> çš„"
-"æ˜ å°„ä¸­è®¾ç½®  <literal>optimistic-lock=\"all\"</literal> 可以在没有版本或者时间"
-"æˆ³å±žæ€§æ˜ å°„çš„æƒ…å†µä¸‹å®žçŽ°ç‰ˆæœ¬æ£€æŸ¥ï¼Œæ­¤æ—¶ Hibernate 将比较一行记录的每个字段的状"
-"态。请注意，只有当 Hibernate 能够比较新旧状态的情况下，这种方式才能生效，也就"
-"æ˜¯è¯´ï¼Œä½ å¿…é¡»ä½¿ç”¨å•ä¸ªé•¿ç”Ÿå‘½å‘¨æœŸ <literal>Session</literal> 模式，而不能使用 "
-"session-per-request-with-detached-objects 模式。 "
+msgid "Legacy database schemas are often static and cannot be modified. Or, other applications might access the same database and will not know how to handle version numbers or even timestamps. In both cases, versioning cannot rely on a particular column in a table. To force a version check with a comparison of the state of all fields in a row but without a version or timestamp property mapping, turn on <literal>optimistic-lock=\"all\"</literal> in the <literal>&lt;class&gt;</literal> mapping. This conceptually only works if Hibernate can compare the old and the new state (i.e., if you use a single long <literal>Session</literal> and not session-per-request-with-detached-objects)."
+msgstr "遗留系统的数据库 Schema é€šå¸¸æ˜¯é™æ€çš„ï¼Œä¸å¯ä¿®æ”¹çš„ã€‚æˆ–è€…ï¼Œå…¶ä»–åº”ç”¨ç¨‹åºä¹Ÿå¯èƒ½è®¿é—®åŒä¸€æ•°æ®åº“ï¼Œæ ¹æœ¬æ— æ³•å¾—çŸ¥å¦‚ä½•å¤„ç†ç‰ˆæœ¬å·ï¼Œç”šè‡³æ—¶é—´æˆ³ã€‚åœ¨ä»¥ä¸Šçš„æ‰€æœ‰åœºæ™¯ä¸­ï¼Œå®žçŽ°ç‰ˆæœ¬åŒ–ä¸èƒ½ä¾é æ•°æ®åº“è¡¨çš„æŸä¸ªç‰¹å®šåˆ—ã€‚åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­è®¾ç½®  <literal>optimistic-lock=\"all\"</literal> å¯ä»¥åœ¨æ²¡æœ‰ç‰ˆæœ¬æˆ–è€…æ—¶é—´æˆ³å±žæ€§æ˜ å°„çš„æƒ…å†µä¸‹å®žçŽ°ç‰ˆæœ¬æ£€æŸ¥ï¼Œæ­¤æ—¶ Hibernate 将比较一行记录的每个字段的状态。请注意，只有当 Hibernate èƒ½å¤Ÿæ¯”è¾ƒæ–°æ—§çŠ¶æ€çš„æƒ…å†µä¸‹ï¼Œè¿™ç§æ–¹å¼æ‰èƒ½ç”Ÿæ•ˆï¼Œä¹Ÿå°±æ˜¯è¯´ï¼Œä½ å¿…é¡»ä½¿ç”¨å•ä¸ªé•¿ç”Ÿå‘½å‘¨æœŸ <literal>Session</literal> 模式，而不能使用 session-per-request-with-detached-objects 模式。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Concurrent modification can be permitted in instances where the changes that "
-"have been made do not overlap. If you set <literal>optimistic-lock=\"dirty"
-"\"</literal> when mapping the <literal>&lt;class&gt;</literal>, Hibernate "
-"will only compare dirty fields during flush."
-msgstr ""
-"æœ‰äº›æƒ…å†µä¸‹ï¼Œåªè¦æ›´æ”¹ä¸å‘ç”Ÿäº¤é”™ï¼Œå¹¶å‘ä¿®æ”¹ä¹Ÿæ˜¯å…è®¸çš„ã€‚å½“ä½ åœ¨ <literal>&lt;"
-"class&gt;</literal> çš„æ˜ å°„ä¸­è®¾ç½® <literal>optimistic-lock=\"dirty\"</"
-"literal>，Hibernate 在同步的时候将只比较有脏数据的字段。 "
+msgid "Concurrent modification can be permitted in instances where the changes that have been made do not overlap. If you set <literal>optimistic-lock=\"dirty\"</literal> when mapping the <literal>&lt;class&gt;</literal>, Hibernate will only compare dirty fields during flush."
+msgstr "æœ‰äº›æƒ…å†µä¸‹ï¼Œåªè¦æ›´æ”¹ä¸å‘ç”Ÿäº¤é”™ï¼Œå¹¶å‘ä¿®æ”¹ä¹Ÿæ˜¯å…è®¸çš„ã€‚å½“ä½ åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­è®¾ç½® <literal>optimistic-lock=\"dirty\"</literal>，Hibernate 在同步的时候将只比较有脏数据的字段。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"In both cases, with dedicated version/timestamp columns or with a full/dirty "
-"field comparison, Hibernate uses a single <literal>UPDATE</literal> "
-"statement, with an appropriate <literal>WHERE</literal> clause, per entity "
-"to execute the version check and update the information. If you use "
-"transitive persistence to cascade reattachment to associated entities, "
-"Hibernate may execute unnecessary updates. This is usually not a problem, "
-"but <emphasis>on update</emphasis> triggers in the database might be "
-"executed even when no changes have been made to detached instances. You can "
-"customize this behavior by setting <literal>select-before-update=\"true\"</"
-"literal> in the <literal>&lt;class&gt;</literal> mapping, forcing Hibernate "
-"to <literal>SELECT</literal> the instance to ensure that changes did occur "
-"before updating the row."
-msgstr ""
-"在以上所有场景中，不管是专门设置一个版本/时间戳列，还是进行全部字段/脏数据字"
-"段比较，Hibernate 都会针对每个实体对象发送一条 <literal>UPDATE</literal>（带"
-"有相应的 <literal>WHERE</literal> 语句 ）的 SQL 语句来执行版本检查和数据更"
-"æ–°ã€‚å¦‚æžœä½ å¯¹å…³è”å®žä½“ è®¾ç½®çº§è”å…³ç³»ä½¿ç”¨ä¼ æ’­æ€§æŒä¹…åŒ–ï¼ˆtransitive persistence），"
-"那么 Hibernate 可能会执行不必 要的update语句。这通常不是个问题，但是数据库里"
-"面对 <emphasis>on update</emphasis> 点火 的触发器可能在脱管对象没有任何更改的"
-"æƒ…å†µä¸‹è¢«è§¦å‘ã€‚å› æ­¤ï¼Œä½ å¯ä»¥åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­ï¼Œé€šè¿‡"
-"设置<literal>select-before-update=\"true\"</literal> 来定制这一行为，强制 "
-"Hibernate  <literal>SELECT</literal> 这个对象实例，从而保证，在更新记录之前，"
-"对象的确是被修改过。 "
+msgid "In both cases, with dedicated version/timestamp columns or with a full/dirty field comparison, Hibernate uses a single <literal>UPDATE</literal> statement, with an appropriate <literal>WHERE</literal> clause, per entity to execute the version check and update the information. If you use transitive persistence to cascade reattachment to associated entities, Hibernate may execute unnecessary updates. This is usually not a problem, but <emphasis>on update</emphasis> triggers in the database might be executed even when no changes have been made to detached instances. You can customize this behavior by setting <literal>select-before-update=\"true\"</literal> in the <literal>&lt;class&gt;</literal> mapping, forcing Hibernate to <literal>SELECT</literal> the instance to ensure that changes did occur before updating the row."
+msgstr "在以上所有场景中，不管是专门设置一个版本/时间戳列，还是进行全部字段/脏数据字段比较，Hibernate 都会针对每个实体对象发送一条 <literal>UPDATE</literal>（带有相应的 <literal>WHERE</literal> 语句 ）的 SQL è¯­å¥æ¥æ‰§è¡Œç‰ˆæœ¬æ£€æŸ¥å’Œæ•°æ®æ›´æ–°ã€‚å¦‚æžœä½ å¯¹å…³è”å®žä½“ è®¾ç½®çº§è”å…³ç³»ä½¿ç”¨ä¼ æ’­æ€§æŒä¹…åŒ–ï¼ˆtransitive persistence），那么 Hibernate 可能会执行不必 要的update语句。这通常不是个问题，但是数据库里面对 <emphasis>on update</emphasis> 点火 çš„è§¦å‘å™¨å¯èƒ½åœ¨è„±ç®¡å¯¹è±¡æ²¡æœ‰ä»»ä½•æ›´æ”¹çš„æƒ…å†µä¸‹è¢«è§¦å‘ã€‚å› æ­¤ï¼Œä½ å¯ä»¥åœ¨ <literal>&lt;class&gt;</literal> çš„æ˜ å°„ä¸­ï¼Œé€šè¿‡è®¾ç½®<literal>select-before-update=\"true\"</literal> 来定制这一行为，强制 Hibernate  <literal>SELECT</literal> 这个对象实例，从而保证，在更新记录之前，对象的确是被修改过。 "
 
 #. Tag: title
 #, no-c-format
@@ -1384,103 +536,53 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"It is not intended that users spend much time worrying about locking "
-"strategies. It is usually enough to specify an isolation level for the JDBC "
-"connections and then simply let the database do all the work. However, "
-"advanced users may wish to obtain exclusive pessimistic locks or re-obtain "
-"locks at the start of a new transaction."
-msgstr ""
-"用户其实并不需要花很多精力去担心锁定策略的问题。通常情况下，只要为 JDBC 连接"
-"指定一下隔离级别，然后让数据库去搞定一切就够了。然而，高级用户有时候希望进行"
-"一个排它的悲观锁定，或者在一个新的事务启动的时候，重新进行锁定。 "
+msgid "It is not intended that users spend much time worrying about locking strategies. It is usually enough to specify an isolation level for the JDBC connections and then simply let the database do all the work. However, advanced users may wish to obtain exclusive pessimistic locks or re-obtain locks at the start of a new transaction."
+msgstr "用户其实并不需要花很多精力去担心锁定策略的问题。通常情况下，只要为 JDBC 连接指定一下隔离级别，然后让数据库去搞定一切就够了。然而，高级用户有时候希望进行一个排它的悲观锁定，或者在一个新的事务启动的时候，重新进行锁定。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"Hibernate will always use the locking mechanism of the database; it never "
-"lock objects in memory."
+msgid "Hibernate will always use the locking mechanism of the database; it never lock objects in memory."
 msgstr "Hibernate 总是使用数据库的锁定机制，从不在内存中锁定对象。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The <literal>LockMode</literal> class defines the different lock levels that "
-"can be acquired by Hibernate. A lock is obtained by the following mechanisms:"
-msgstr ""
-"类 <literal>LockMode</literal> 定义了 Hibernate 所需的不同的锁定级别。一个锁"
-"定可以通过以下的机制来设置："
+msgid "The <literal>LockMode</literal> class defines the different lock levels that can be acquired by Hibernate. A lock is obtained by the following mechanisms:"
+msgstr "类 <literal>LockMode</literal> 定义了 Hibernate 所需的不同的锁定级别。一个锁定可以通过以下的机制来设置："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate "
-"updates or inserts a row."
-msgstr ""
-"当 Hibernate 更新或者插入一行记录的时候，锁定级别自动设置为 "
-"<literal>LockMode.WRITE</literal>。"
+msgid "<literal>LockMode.WRITE</literal> is acquired automatically when Hibernate updates or inserts a row."
+msgstr "当 Hibernate 更新或者插入一行记录的时候，锁定级别自动设置为 <literal>LockMode.WRITE</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>LockMode.UPGRADE</literal> can be acquired upon explicit user "
-"request using <literal>SELECT ... FOR UPDATE</literal> on databases which "
-"support that syntax."
-msgstr ""
-"当用户显式的使用数据库支持的 SQL æ ¼å¼ <literal>SELECT ... FOR UPDATE</"
-"literal> 发送 SQL 的时候，锁定级别设置为 <literal>LockMode.UPGRADE</"
-"literal>。 "
+msgid "<literal>LockMode.UPGRADE</literal> can be acquired upon explicit user request using <literal>SELECT ... FOR UPDATE</literal> on databases which support that syntax."
+msgstr "当用户显式的使用数据库支持的 SQL æ ¼å¼ <literal>SELECT ... FOR UPDATE</literal> 发送 SQL 的时候，锁定级别设置为 <literal>LockMode.UPGRADE</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>LockMode.UPGRADE_NOWAIT</literal> can be acquired upon explicit "
-"user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under "
-"Oracle."
-msgstr ""
-"当用户显式的使用 Oracle 数据库的 SQL 语句 <literal>SELECT ... FOR UPDATE "
-"NOWAIT</literal> 的时候，锁定级别设置 <literal>LockMode.UPGRADE_NOWAIT</"
-"literal>。 "
+msgid "<literal>LockMode.UPGRADE_NOWAIT</literal> can be acquired upon explicit user request using a <literal>SELECT ... FOR UPDATE NOWAIT</literal> under Oracle."
+msgstr "当用户显式的使用 Oracle 数据库的 SQL 语句 <literal>SELECT ... FOR UPDATE NOWAIT</literal> 的时候，锁定级别设置 <literal>LockMode.UPGRADE_NOWAIT</literal>。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>LockMode.READ</literal> is acquired automatically when Hibernate "
-"reads data under Repeatable Read or Serializable isolation level. It can be "
-"re-acquired by explicit user request."
-msgstr ""
-"当 Hibernate 在“可重复读”或者是“序列化”数据库隔离级别下读取数据的时候，锁定模"
-"式自动设置为 <literal>LockMode.READ</literal>。这种模式也可以通过用户显式指定"
-"进行设置。 "
+msgid "<literal>LockMode.READ</literal> is acquired automatically when Hibernate reads data under Repeatable Read or Serializable isolation level. It can be re-acquired by explicit user request."
+msgstr "当 Hibernate 在“可重复读”或者是“序列化”数据库隔离级别下读取数据的时候，锁定模式自动设置为 <literal>LockMode.READ</literal>。这种模式也可以通过用户显式指定进行设置。 "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>LockMode.NONE</literal> represents the absence of a lock. All "
-"objects switch to this lock mode at the end of a <literal>Transaction</"
-"literal>. Objects associated with the session via a call to <literal>update()"
-"</literal> or <literal>saveOrUpdate()</literal> also start out in this lock "
-"mode."
-msgstr ""
-"<literal>LockMode.NONE</literal> ä»£è¡¨æ— éœ€é”å®šã€‚åœ¨ <literal>Transaction</"
-"literal> 结束时， 所有的对象都切换到该模式上来。与 session 相关联的对象通过调"
-"用 <literal>update()</literal> 或者 <literal>saveOrUpdate()</literal> 脱离该"
-"模式。"
+msgid "<literal>LockMode.NONE</literal> represents the absence of a lock. All objects switch to this lock mode at the end of a <literal>Transaction</literal>. Objects associated with the session via a call to <literal>update()</literal> or <literal>saveOrUpdate()</literal> also start out in this lock mode."
+msgstr "<literal>LockMode.NONE</literal> ä»£è¡¨æ— éœ€é”å®šã€‚åœ¨ <literal>Transaction</literal> 结束时， 所有的对象都切换到该模式上来。与 session 相关联的对象通过调用 <literal>update()</literal> 或者 <literal>saveOrUpdate()</literal> 脱离该模式。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The \"explicit user request\" is expressed in one of the following ways:"
+msgid "The \"explicit user request\" is expressed in one of the following ways:"
 msgstr "\"显式的用户指定\"å¯ä»¥é€šè¿‡ä»¥ä¸‹å‡ ç§æ–¹å¼ä¹‹ä¸€æ¥è¡¨ç¤ºï¼š"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</"
-"literal>."
-msgstr ""
-"调用 <literal>Session.load()</literal> 的时候指定<literal>锁定模式"
-"（LockMode）</literal>。"
+msgid "A call to <literal>Session.load()</literal>, specifying a <literal>LockMode</literal>."
+msgstr "调用 <literal>Session.load()</literal> 的时候指定<literal>锁定模式（LockMode）</literal>。"
 
 #. Tag: para
 #, no-c-format
@@ -1494,46 +596,18 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If <literal>Session.load()</literal> is called with <literal>UPGRADE</"
-"literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was "
-"not yet loaded by the session, the object is loaded using "
-"<literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is "
-"called for an object that is already loaded with a less restrictive lock "
-"than the one requested, Hibernate calls <literal>lock()</literal> for that "
-"object."
-msgstr ""
-"如果在 <literal>UPGRADE</literal> 或者 <literal>UPGRADE_NOWAIT</literal> 锁定"
-"模式下调用 <literal>Session.load()</literal>，并且要读取的对象尚未被 session "
-"载入过，那么对象通过 <literal>SELECT ... FOR UPDATE</literal> è¿™æ ·çš„ SQL 语句"
-"被载入。如果为一个对象调用  <literal>load()</literal> 方法时，该对象已经在另"
-"一个较少限制的锁定模式下被载入了，那么  Hibernate 就对该对象调用 "
-"<literal>lock()</literal> 方法。"
+msgid "If <literal>Session.load()</literal> is called with <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, and the requested object was not yet loaded by the session, the object is loaded using <literal>SELECT ... FOR UPDATE</literal>. If <literal>load()</literal> is called for an object that is already loaded with a less restrictive lock than the one requested, Hibernate calls <literal>lock()</literal> for that object."
+msgstr "如果在 <literal>UPGRADE</literal> 或者 <literal>UPGRADE_NOWAIT</literal> 锁定模式下调用 <literal>Session.load()</literal>，并且要读取的对象尚未被 session 载入过，那么对象通过 <literal>SELECT ... FOR UPDATE</literal> è¿™æ ·çš„ SQL 语句被载入。如果为一个对象调用  <literal>load()</literal> 方法时，该对象已经在另一个较少限制的锁定模式下被载入了，那么  Hibernate 就对该对象调用 <literal>lock()</literal> 方法。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>Session.lock()</literal> performs a version number check if the "
-"specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> "
-"or <literal>UPGRADE_NOWAIT</literal>. In the case of <literal>UPGRADE</"
-"literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR "
-"UPDATE</literal> is used."
-msgstr ""
-"如果指定的锁定模式是 <literal>READ</literal>，<literal>UPGRADE</literal> 或  "
-"<literal>UPGRADE_NOWAIT</literal>，那么 <literal>Session.lock()</literal> 就"
-"执行版本号检查。（在 <literal>UPGRADE</literal> 或者 "
-"<literal>UPGRADE_NOWAIT</literal> 锁定模式下，执行 <literal>SELECT ... FOR "
-"UPDATE</literal>è¿™æ ·çš„SQL语句。）"
+msgid "<literal>Session.lock()</literal> performs a version number check if the specified lock mode is <literal>READ</literal>, <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>. In the case of <literal>UPGRADE</literal> or <literal>UPGRADE_NOWAIT</literal>, <literal>SELECT ... FOR UPDATE</literal> is used."
+msgstr "如果指定的锁定模式是 <literal>READ</literal>，<literal>UPGRADE</literal> 或  <literal>UPGRADE_NOWAIT</literal>，那么 <literal>Session.lock()</literal> 就执行版本号检查。（在 <literal>UPGRADE</literal> 或者 <literal>UPGRADE_NOWAIT</literal> 锁定模式下，执行 <literal>SELECT ... FOR UPDATE</literal>è¿™æ ·çš„SQL语句。）"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"If the requested lock mode is not supported by the database, Hibernate uses "
-"an appropriate alternate mode instead of throwing an exception. This ensures "
-"that applications are portable."
-msgstr ""
-"如果数据库不支持用户设置的锁定模式，Hibernate 将使用适当的替代模式（而不是扔"
-"出异常）。这一点可以确保应用程序的可移植性。 "
+msgid "If the requested lock mode is not supported by the database, Hibernate uses an appropriate alternate mode instead of throwing an exception. This ensures that applications are portable."
+msgstr "如果数据库不支持用户设置的锁定模式，Hibernate 将使用适当的替代模式（而不是扔出异常）。这一点可以确保应用程序的可移植性。 "
 
 #. Tag: title
 #, no-c-format
@@ -1542,133 +616,51 @@
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"One of the legacies of Hibernate 2.x JDBC connection management meant that a "
-"<literal>Session</literal> would obtain a connection when it was first "
-"required and then maintain that connection until the session was closed. "
-"Hibernate 3.x introduced the notion of connection release modes that would "
-"instruct a session how to handle its JDBC connections. The following "
-"discussion is pertinent only to connections provided through a configured "
-"<literal>ConnectionProvider</literal>. User-supplied connections are outside "
-"the breadth of this discussion. The different release modes are identified "
-"by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</"
-"literal>:"
-msgstr ""
-"Hibernate 关于 JDBC 连接管理的旧（2.x）行为是，<literal>Session</literal> 在"
-"第一次需要的时候获取一个连接，在 session 关闭之前一直会持有这个连接。"
-"Hibernate 引入了连接释放的概念，来告诉 session 如何处理它的 JDBC 连接。注意，"
-"下面的讨论只适用于采用配置 <literal>ConnectionProvider</literal> 来提供连接的"
-"æƒ…å†µï¼Œç”¨æˆ·è‡ªå·±æä¾›çš„è¿žæŽ¥ä¸Žè¿™é‡Œçš„è®¨è®ºæ— å…³ã€‚é€šè¿‡ <literal>org.hibernate."
-"ConnectionReleaseMode</literal> 的不同枚举值来使用不用的释放模式："
+msgid "One of the legacies of Hibernate 2.x JDBC connection management meant that a <literal>Session</literal> would obtain a connection when it was first required and then maintain that connection until the session was closed. Hibernate 3.x introduced the notion of connection release modes that would instruct a session how to handle its JDBC connections. The following discussion is pertinent only to connections provided through a configured <literal>ConnectionProvider</literal>. User-supplied connections are outside the breadth of this discussion. The different release modes are identified by the enumerated values of <literal>org.hibernate.ConnectionReleaseMode</literal>:"
+msgstr "Hibernate 关于 JDBC 连接管理的旧（2.x）行为是，<literal>Session</literal> 在第一次需要的时候获取一个连接，在 session 关闭之前一直会持有这个连接。Hibernate 引入了连接释放的概念，来告诉 session 如何处理它的 JDBC 连接。注意，下面的讨论只适用于采用配置 <literal>ConnectionProvider</literal> æ¥æä¾›è¿žæŽ¥çš„æƒ…å†µï¼Œç”¨æˆ·è‡ªå·±æä¾›çš„è¿žæŽ¥ä¸Žè¿™é‡Œçš„è®¨è®ºæ— å…³ã€‚é€šè¿‡ <literal>org.hibernate.ConnectionReleaseMode</literal> 的不同枚举值来使用不用的释放模式："
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>ON_CLOSE</literal>: is the legacy behavior described above. The "
-"Hibernate session obtains a connection when it first needs to perform some "
-"JDBC access and maintains that connection until the session is closed."
-msgstr ""
-"<literal>ON_CLOSE</literal>：基本上就是上面提到的老式行为。Hibernate session "
-"在第一次需要进行 JDBC 操作的时候获取连接，然后持有它，直到 session 关闭。"
+msgid "<literal>ON_CLOSE</literal>: is the legacy behavior described above. The Hibernate session obtains a connection when it first needs to perform some JDBC access and maintains that connection until the session is closed."
+msgstr "<literal>ON_CLOSE</literal>：基本上就是上面提到的老式行为。Hibernate session 在第一次需要进行 JDBC 操作的时候获取连接，然后持有它，直到 session 关闭。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>AFTER_TRANSACTION</literal>: releases connections after a "
-"<literal>org.hibernate.Transaction</literal> has been completed."
-msgstr ""
-"<literal>AFTER_TRANSACTION</literal>：在 <literal>org.hibernate.Transaction</"
-"literal> 结束后释放连接。"
+msgid "<literal>AFTER_TRANSACTION</literal>: releases connections after a <literal>org.hibernate.Transaction</literal> has been completed."
+msgstr "<literal>AFTER_TRANSACTION</literal>：在 <literal>org.hibernate.Transaction</literal> 结束后释放连接。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release): "
-"releases connections after every statement execution. This aggressive "
-"releasing is skipped if that statement leaves open resources associated with "
-"the given session. Currently the only situation where this occurs is through "
-"the use of <literal>org.hibernate.ScrollableResults</literal>."
-msgstr ""
-"<literal>AFTER_STATEMENT</literal>（也被称做积极释放）：在每一条语句被执行后"
-"就释放连接。但假若语句留下了与 session 相关的资源，那就不会被释放。目前唯一的"
-"这种情形就是使用 <literal>org.hibernate.ScrollableResults</literal>。"
+msgid "<literal>AFTER_STATEMENT</literal> (also referred to as aggressive release): releases connections after every statement execution. This aggressive releasing is skipped if that statement leaves open resources associated with the given session. Currently the only situation where this occurs is through the use of <literal>org.hibernate.ScrollableResults</literal>."
+msgstr "<literal>AFTER_STATEMENT</literal>（也被称做积极释放）：在每一条语句被执行后就释放连接。但假若语句留下了与 session 相关的资源，那就不会被释放。目前唯一的这种情形就是使用 <literal>org.hibernate.ScrollableResults</literal>。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"The configuration parameter <literal>hibernate.connection.release_mode</"
-"literal> is used to specify which release mode to use. The possible values "
-"are as follows:"
-msgstr ""
-"<literal>hibernate.connection.release_mode</literal> 配置参数用来指定使用哪一"
-"种释放模式。可能的值有： "
+msgid "The configuration parameter <literal>hibernate.connection.release_mode</literal> is used to specify which release mode to use. The possible values are as follows:"
+msgstr "<literal>hibernate.connection.release_mode</literal> 配置参数用来指定使用哪一种释放模式。可能的值有： "
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>auto</literal> (the default): this choice delegates to the release "
-"mode returned by the <literal>org.hibernate.transaction.TransactionFactory."
-"getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this "
-"returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, "
-"this returns ConnectionReleaseMode.AFTER_TRANSACTION. Do not change this "
-"default behavior as failures due to the value of this setting tend to "
-"indicate bugs and/or invalid assumptions in user code."
-msgstr ""
-"<literal>auto</literal>（默认）：这一选择把释放模式委派给 <literal>org."
-"hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> æ–¹"
-"法。对 JTATransactionFactory 来说，它会返回 ConnectionReleaseMode."
-"AFTER_STATEMENT；对　JDBCTransactionFactory　来说，则是ConnectionReleaseMode."
-"AFTER_TRANSACTIONã€‚å¾ˆå°‘éœ€è¦ä¿®æ”¹è¿™ä¸€é»˜è®¤è¡Œä¸ºï¼Œå› ä¸ºå‡è‹¥è®¾ç½®ä¸å½“ï¼Œå°±ä¼šå¸¦æ¥ bug，"
-"æˆ–è€…ç»™ç”¨æˆ·ä»£ç å¸¦æ¥è¯¯å¯¼ã€‚"
+msgid "<literal>auto</literal> (the default): this choice delegates to the release mode returned by the <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> method. For JTATransactionFactory, this returns ConnectionReleaseMode.AFTER_STATEMENT; for JDBCTransactionFactory, this returns ConnectionReleaseMode.AFTER_TRANSACTION. Do not change this default behavior as failures due to the value of this setting tend to indicate bugs and/or invalid assumptions in user code."
+msgstr "<literal>auto</literal>（默认）：这一选择把释放模式委派给 <literal>org.hibernate.transaction.TransactionFactory.getDefaultReleaseMode()</literal> 方法。对 JTATransactionFactory 来说，它会返回 ConnectionReleaseMode.AFTER_STATEMENT；对　JDBCTransactionFactory　来说，则是ConnectionReleaseMode.AFTER_TRANSACTIONã€‚å¾ˆå°‘éœ€è¦ä¿®æ”¹è¿™ä¸€é»˜è®¤è¡Œä¸ºï¼Œå› ä¸ºå‡è‹¥è®¾ç½®ä¸å½“ï¼Œå°±ä¼šå¸¦æ¥ bugï¼Œæˆ–è€…ç»™ç”¨æˆ·ä»£ç å¸¦æ¥è¯¯å¯¼ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>on_close</literal>: uses ConnectionReleaseMode.ON_CLOSE. This "
-"setting is left for backwards compatibility, but its use is discouraged."
-msgstr ""
-"<literal>on_close</literal>：使用 ConnectionReleaseMode.ON_CLOSE。这种方式是"
-"为了向下兼容的,但是已经完全不被鼓励使用了。"
+msgid "<literal>on_close</literal>: uses ConnectionReleaseMode.ON_CLOSE. This setting is left for backwards compatibility, but its use is discouraged."
+msgstr "<literal>on_close</literal>：使用 ConnectionReleaseMode.ON_CLOSE。这种方式是为了向下兼容的,但是已经完全不被鼓励使用了。"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>after_transaction</literal>: uses ConnectionReleaseMode."
-"AFTER_TRANSACTION. This setting should not be used in JTA environments. Also "
-"note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is "
-"considered to be in auto-commit mode, connections will be released as if the "
-"release mode were AFTER_STATEMENT."
-msgstr ""
-"<literal>after_transaction</literal>：使用 ConnectionReleaseMode."
-"AFTER_TRANSACTION。这一设置不应该在 JTA 环境下使用。也要注意，使用 "
-"ConnectionReleaseMode.AFTER_TRANSACTION 的时候，假若session 处于 auto-commit "
-"状态，连接会像 AFTER_STATEMENT é‚£æ ·è¢«é‡Šæ”¾ã€‚"
+msgid "<literal>after_transaction</literal>: uses ConnectionReleaseMode.AFTER_TRANSACTION. This setting should not be used in JTA environments. Also note that with ConnectionReleaseMode.AFTER_TRANSACTION, if a session is considered to be in auto-commit mode, connections will be released as if the release mode were AFTER_STATEMENT."
+msgstr "<literal>after_transaction</literal>：使用 ConnectionReleaseMode.AFTER_TRANSACTION。这一设置不应该在 JTA 环境下使用。也要注意，使用 ConnectionReleaseMode.AFTER_TRANSACTION 的时候，假若session 处于 auto-commit 状态，连接会像 AFTER_STATEMENT é‚£æ ·è¢«é‡Šæ”¾ã€‚"
 
 #. Tag: para
 #, no-c-format
-msgid ""
-"<literal>after_statement</literal>: uses ConnectionReleaseMode."
-"AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</"
-"literal> is consulted to see if it supports this setting "
-"(<literal>supportsAggressiveRelease()</literal>). If not, the release mode "
-"is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only "
-"safe in environments where we can either re-acquire the same underlying JDBC "
-"connection each time you make a call into <literal>ConnectionProvider."
-"getConnection()</literal> or in auto-commit environments where it does not "
-"matter if we re-establish the same connection."
-msgstr ""
-"<literal>after_statement</literal>：使用 ConnectionReleaseMode."
-"AFTER_STATEMENT。除此之外，会查询配置的 <literal>ConnectionProvider</"
-"literal>，是否它支持这一设置（<literal>supportsAggressiveRelease()</"
-"literal>）。假若不支持，释放模式会被设置为  ConnectionReleaseMode."
-"AFTER_TRANSACTIONã€‚åªæœ‰åœ¨ä½ æ¯æ¬¡è°ƒç”¨  <literal>ConnectionProvider."
-"getConnection()</literal> 获取底层 JDBC 连接的时候，都可以确信获得同一个连接"
-"的时候，这一设置才是安全的；或者在 auto-commit çŽ¯å¢ƒä¸­ï¼Œä½ å¯ä»¥ä¸ç®¡æ˜¯å¦æ¯æ¬¡éƒ½èŽ·"
-"得同一个连接的时候，这才是安全的。"
+msgid "<literal>after_statement</literal>: uses ConnectionReleaseMode.AFTER_STATEMENT. Additionally, the configured <literal>ConnectionProvider</literal> is consulted to see if it supports this setting (<literal>supportsAggressiveRelease()</literal>). If not, the release mode is reset to ConnectionReleaseMode.AFTER_TRANSACTION. This setting is only safe in environments where we can either re-acquire the same underlying JDBC connection each time you make a call into <literal>ConnectionProvider.getConnection()</literal> or in auto-commit environments where it does not matter if we re-establish the same connection."
+msgstr "<literal>after_statement</literal>：使用 ConnectionReleaseMode.AFTER_STATEMENT。除此之外，会查询配置的 <literal>ConnectionProvider</literal>，是否它支持这一设置（<literal>supportsAggressiveRelease()</literal>）。假若不支持，释放模式会被设置为  ConnectionReleaseMode.AFTER_TRANSACTIONã€‚åªæœ‰åœ¨ä½ æ¯æ¬¡è°ƒç”¨  <literal>ConnectionProvider.getConnection()</literal> 获取底层 JDBC 连接的时候，都可以确信获得同一个连接的时候，这一设置才是安全的；或者在 auto-commit çŽ¯å¢ƒä¸­ï¼Œä½ å¯ä»¥ä¸ç®¡æ˜¯å¦æ¯æ¬¡éƒ½èŽ·å¾—åŒä¸€ä¸ªè¿žæŽ¥çš„æ—¶å€™ï¼Œè¿™æ‰æ˜¯å®‰å…¨çš„ã€‚"
 
 #~ msgid "foo==bar"
 #~ msgstr "foo==bar"
-
 #~ msgid ""
 #~ "<![CDATA[// Non-managed environment idiom\n"
 #~ "Session sess = factory.openSession();\n"
@@ -1707,7 +699,6 @@
 #~ "finally {\n"
 #~ "    sess.close();\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// Non-managed environment idiom with getCurrentSession()\n"
 #~ "try {\n"
@@ -1736,7 +727,6 @@
 #~ "    factory.getCurrentSession().getTransaction().rollback();\n"
 #~ "    throw e; // or display error message\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// BMT idiom\n"
 #~ "Session sess = factory.openSession();\n"
@@ -1775,7 +765,6 @@
 #~ "finally {\n"
 #~ "    sess.close();\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// BMT idiom with getCurrentSession()\n"
 #~ "try {\n"
@@ -1812,7 +801,6 @@
 #~ "    tx.rollback();\n"
 #~ "    throw e; // or display error message\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// CMT idiom\n"
 #~ " Session sess = factory.getCurrentSession();\n"
@@ -1827,7 +815,6 @@
 #~ " // do some work\n"
 #~ " ...\n"
 #~ "]]>"
-
 #~ msgid ""
 #~ "<![CDATA[\n"
 #~ "Session sess = factory.openSession();\n"
@@ -1868,7 +855,6 @@
 #~ "finally {\n"
 #~ "    sess.close();\n"
 #~ "}]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// foo is an instance loaded by a previous Session\n"
 #~ "session = factory.openSession();\n"
@@ -1895,7 +881,6 @@
 #~ "\n"
 #~ "t.commit();\n"
 #~ "session.close();]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// foo is an instance loaded earlier by the old session\n"
 #~ "Transaction t = session.beginTransaction(); // Obtain a new JDBC "
@@ -1916,7 +901,6 @@
 #~ "session.flush();    // Only for last transaction in conversation\n"
 #~ "t.commit();         // Also return JDBC connection\n"
 #~ "session.close();    // Only for last transaction in conversation]]>"
-
 #~ msgid ""
 #~ "<![CDATA[// foo is an instance loaded by a previous Session\n"
 #~ "foo.setProperty(\"bar\");\n"
@@ -1935,3 +919,4 @@
 #~ "loaded already\n"
 #~ "t.commit();\n"
 #~ "session.close();]]>"
+

Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po	2009-12-10 21:31:45 UTC (rev 97707)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/tutorial.po	2009-12-11 00:50:05 UTC (rev 97708)
@@ -7,7 +7,7 @@
 "Project-Id-Version: tutorial\n"
 "Report-Msgid-Bugs-To: http://bugs.kde.org\n"
 "POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2009-12-07 21:51+1000\n"
+"PO-Revision-Date: 2009-12-11 10:12+1000\n"
 "Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
 "Language-Team:  <en at li.org>\n"
 "MIME-Version: 1.0\n"
@@ -328,7 +328,7 @@
 #. Tag: para
 #, no-c-format
 msgid "Hibernate offers three methods of current session tracking. The \"thread\" based method is not intended for production use; it is merely useful for prototyping and tutorials such as this one. Current session tracking is discussed in more detail later on."
-msgstr ""
+msgstr "Hibernate 提供三种跟踪当前会话的方法。基于“线程”的方法不适合于产品环境，它仅用于 prototyping 和教学用途。后面将更详细地讨论会话跟踪。"
 
 #. Tag: para
 #, no-c-format
@@ -348,12 +348,12 @@
 #. Tag: para
 #, no-c-format
 msgid "To run this, we will make use of the Maven exec plugin to call our class with the necessary classpath setup: <command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"store\"</command>"
-msgstr ""
+msgstr "要运行它，我们将使用 Maven exec 插件以及必要的 classpath 设置来进行调用：<command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"store\"</command>。"
 
 #. Tag: para
 #, no-c-format
 msgid "You may need to perform <command>mvn compile</command> first."
-msgstr ""
+msgstr "ä½ å¯èƒ½éœ€è¦å…ˆæ‰§è¡Œ <command>mvn compile</command>。"
 
 #. Tag: para
 #, no-c-format
@@ -383,7 +383,7 @@
 #. Tag: para
 #, no-c-format
 msgid "Now we can call our new functionality, again using the Maven exec plugin: <command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"list\"</command>"
-msgstr ""
+msgstr "现在我们可以再次用 Maven exec plugin - <command>mvn exec:java -Dexec.mainClass=\"org.hibernate.tutorial.EventManager\" -Dexec.args=\"list\"</command> 调用新的功能了。"
 
 #. Tag: title
 #, no-c-format
@@ -408,12 +408,12 @@
 #. Tag: para
 #, no-c-format
 msgid "Save this to a file named <filename>src/main/java/org/hibernate/tutorial/domain/Person.java</filename>"
-msgstr ""
+msgstr "把它保存为文件 <filename>src/main/java/org/hibernate/tutorial/domain/Person.java</filename>。"
 
 #. Tag: para
 #, no-c-format
 msgid "Next, create the new mapping file as <filename>src/main/resources/org/hibernate/tutorial/domain/Person.hbm.xml</filename>"
-msgstr ""
+msgstr "ç„¶åŽï¼Œåˆ›å»ºæ–°çš„æ˜ å°„æ–‡ä»¶ <filename>src/main/resources/org/hibernate/tutorial/domain/Person.hbm.xml</filename>。"
 
 #. Tag: para
 #, no-c-format
@@ -498,7 +498,7 @@
 #. Tag: para
 #, no-c-format
 msgid "Let's add a collection of email addresses to the <literal>Person</literal> entity. This will be represented as a <interfacename>java.util.Set</interfacename> of <classname>java.lang.String</classname> instances:"
-msgstr ""
+msgstr "让我们在 <literal>Person</literal> å®žä½“é‡Œæ·»åŠ ä¸€ä¸ªç”µå­é‚®ä»¶çš„é›†åˆã€‚è¿™å°†ä»¥ <classname>java.lang.String</classname> 实例的 <interfacename>java.util.Set</interfacename> 出现："
 
 #. Tag: para
 #, no-c-format
@@ -543,7 +543,7 @@
 #. Tag: para
 #, no-c-format
 msgid "A relational database is more flexible than a network programming language, in that it does not need a navigation direction; data can be viewed and retrieved in any possible way."
-msgstr ""
+msgstr "å…³ç³»åž‹æ•°æ®åº“æ¯”ç½‘ç»œç¼–ç¨‹è¯­è¨€æ›´ä¸ºçµæ´»ï¼Œå› ä¸ºå®ƒä¸éœ€è¦æ–¹å‘å¯¼èˆªï¼Œå…¶æ•°æ®å¯ä»¥ç”¨ä»»ä½•å¯èƒ½çš„æ–¹å¼è¿›è¡ŒæŸ¥çœ‹å’Œæå–ã€‚"
 
 #. Tag: para
 #, no-c-format
@@ -613,7 +613,7 @@
 #. Tag: para
 #, no-c-format
 msgid "Save this servlet as <filename>src/main/java/org/hibernate/tutorial/web/EventManagerServlet.java</filename>"
-msgstr ""
+msgstr "把这个 servlet 保存为 <filename>src/main/java/org/hibernate/tutorial/web/EventManagerServlet.java</filename>。"
 
 #. Tag: para
 #, no-c-format
@@ -673,7 +673,7 @@
 #. Tag: para
 #, no-c-format
 msgid "To deploy this application for testing we must create a Web ARchive (WAR). First we must define the WAR descriptor as <filename>src/main/webapp/WEB-INF/web.xml</filename>"
-msgstr ""
+msgstr "要部署这个应用程序以进行测试，我们必须出具一个 Web ARchive (WAR)。首先我们必须定义 WAR 描述符为 <filename>src/main/webapp/WEB-INF/web.xml</filename>。"
 
 #. Tag: para
 #, no-c-format
@@ -683,7 +683,7 @@
 #. Tag: para
 #, no-c-format
 msgid "If you do not have Tomcat installed, download it from <ulink url=\"http://tomcat.apache.org/\" /> and follow the installation instructions. Our application requires no changes to the standard Tomcat configuration."
-msgstr ""
+msgstr "å¦‚æžœä½ è¿˜æ²¡æœ‰å®‰è£… Tomcat，请从 <ulink url=\"http://tomcat.apache.org/\" /> ä¸‹è½½å¹¶æŒ‰ç…§å®‰è£…è¯´æ˜Žè¿›è¡Œå®‰è£…ã€‚æˆ‘ä»¬çš„åº”ç”¨ç¨‹åºä¸éœ€è¦å¯¹æ ‡å‡†çš„ Tomcat 配置进行修改。"
 
 #. Tag: para
 #, no-c-format