[jboss-cvs] JBossAS SVN: r97441 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Fri Dec 4 00:22:06 EST 2009
Author: xhuang at jboss.com
Date: 2009-12-04 00:22:06 -0500 (Fri, 04 Dec 2009)
New Revision: 97441
Modified:
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_sql.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/session_api.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/toolset_guide.po
Log:
update
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-04 04:13:58 UTC (rev 97440)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/query_sql.po 2009-12-04 05:22:06 UTC (rev 97441)
@@ -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-04 15:21+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -20,44 +20,24 @@
msgstr "Native SQL 查询"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can also express queries in the native SQL dialect of your database. "
-"This is useful if you want to utilize database-specific features such as "
-"query hints or the <literal>CONNECT</literal> keyword in Oracle. It also "
-"provides a clean migration path from a direct SQL/JDBC based application to "
-"Hibernate."
-msgstr ""
-"你也可以使用你的数据库的 Native SQL 语言来查询数据。这对你在要使用数据库的某"
-"些特性的时候（比如说在查询提示或者 Oracle 中的 <literal>CONNECT</literal> 关"
-"键字），这是非常有用的。这就能够扫清你把原来直接使用 SQL/JDBC 的程序迁移到基"
-"于 Hibernate 应用的道路上的障碍。"
+#, no-c-format
+msgid "You can also express queries in the native SQL dialect of your database. This is useful if you want to utilize database-specific features such as query hints or the <literal>CONNECT</literal> keyword in Oracle. It also provides a clean migration path from a direct SQL/JDBC based application to Hibernate."
+msgstr "你也可以使用你的数据库的 Native SQL 语言来查询数据。这对你在要使用数据库的某些特性的时候（比如说在查询提示或者 Oracle 中的 <literal>CONNECT</literal> 关键字），这是非常有用的。这就能够扫清你把原来直接使用 SQL/JDBC 的程序迁移到基于 Hibernate 应用的道路上的障碍。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate3 allows you to specify handwritten SQL, including stored "
-"procedures, for all create, update, delete, and load operations."
-msgstr ""
-"Hibernate3 允许你使用手写的 sql 来完成所有的 create，update，delete 和 load "
-"操作（包括存储过程）"
+#, no-c-format
+msgid "Hibernate3 allows you to specify handwritten SQL, including stored procedures, for all create, update, delete, and load operations."
+msgstr "Hibernate3 允许你使用手写的 sql 来完成所有的 create、update、delete 和 load 操作（包括存储过程） "
#. Tag: title
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Using a <literal>SQLQuery</literal>"
-msgstr "或存放在一个 <literal>List</literal> 对象中，"
+msgstr "使用 <literal>SQLQuery</literal>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Execution of native SQL queries is controlled via the <literal>SQLQuery</"
-"literal> interface, which is obtained by calling <literal>Session."
-"createSQLQuery()</literal>. The following sections describe how to use this "
-"API for querying."
-msgstr ""
-"对原生 SQL 查询执行的控制是通过 <literal>SQLQuery</literal> 接口进行的，通过"
-"执行<literal>Session.createSQLQuery()</literal>获取这个接口。下面来描述如何使"
-"用这个 API 进行查询。"
+#, no-c-format
+msgid "Execution of native SQL queries is controlled via the <literal>SQLQuery</literal> interface, which is obtained by calling <literal>Session.createSQLQuery()</literal>. The following sections describe how to use this API for querying."
+msgstr "对原生 SQL 查询执行的控制是通过 <literal>SQLQuery</literal> 接口进行的，通过执行<literal>Session.createSQLQuery()</literal>获取这个接口。下面来描述如何使用这个 API 进行查询。 "
#. Tag: title
#, no-c-format
@@ -70,25 +50,14 @@
msgstr "最基本的 SQL 查询就是获得一个标量（数值）的列表。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"These will return a List of Object arrays (Object[]) with scalar values for "
-"each column in the CATS table. Hibernate will use ResultSetMetadata to "
-"deduce the actual order and types of the returned scalar values."
-msgstr ""
-"它们都将返回一个 Object 数组（Object[]）组成的 List，数组每个元素都是 CATS 表"
-"的一个字段值。Hibernate 会使用 ResultSetMetadata 来判定返回的标量值的实际顺序"
-"和类型。"
+#, no-c-format
+msgid "These will return a List of Object arrays (Object[]) with scalar values for each column in the CATS table. Hibernate will use ResultSetMetadata to deduce the actual order and types of the returned scalar values."
+msgstr "它们都将返回一个 Object 数组（Object[]）组成的 List，数组每个元素都是 CATS 表的一个字段值。Hibernate 会使用 ResultSetMetadata 来判定返回的标量值的实际顺序和类型。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"To avoid the overhead of using <literal>ResultSetMetadata</literal>, or "
-"simply to be more explicit in what is returned, one can use "
-"<literal>addScalar()</literal>:"
-msgstr ""
-"如果要避免过多的使用 <literal>ResultSetMetadata</literal>，或者只是为了更加明"
-"确的指名返回值，可以使用 <literal>addScalar()</literal>。"
+#, no-c-format
+msgid "To avoid the overhead of using <literal>ResultSetMetadata</literal>, or simply to be more explicit in what is returned, one can use <literal>addScalar()</literal>:"
+msgstr "如果要避免过多的使用 <literal>ResultSetMetadata</literal>，或者只是为了更加明确的指名返回值，可以使用 <literal>addScalar()</literal>： "
#. Tag: para
#, no-c-format
@@ -106,49 +75,24 @@
msgstr "要返回的字段和类型"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This will return Object arrays, but now it will not use "
-"<literal>ResultSetMetadata</literal> but will instead explicitly get the ID, "
-"NAME and BIRTHDATE column as respectively a Long, String and a Short from "
-"the underlying resultset. This also means that only these three columns will "
-"be returned, even though the query is using <literal>*</literal> and could "
-"return more than the three listed columns."
-msgstr ""
-"它仍然会返回 Object 数组,但是此时不再使用 <literal>ResultSetMetdata</"
-"literal>，而是明确的将 ID，NAME 和 BIRTHDATE 按照 Long，String 和 Short 类型"
-"从 resultset 中取出。同时，也指明了就算 query 是使用 <literal>*</literal> 来"
-"查询的，可能获得超过列出的这三个字段，也仅仅会返回这三个字段。"
+#, no-c-format
+msgid "This will return Object arrays, but now it will not use <literal>ResultSetMetadata</literal> but will instead explicitly get the ID, NAME and BIRTHDATE column as respectively a Long, String and a Short from the underlying resultset. This also means that only these three columns will be returned, even though the query is using <literal>*</literal> and could return more than the three listed columns."
+msgstr "它仍然会返回 Object 数组,但是此时不再使用 <literal>ResultSetMetdata</literal>，而是明确的将 ID，NAME 和 BIRTHDATE 按照 Long，String 和 Short 类型从 resultset 中取出。同时，也指明了就算 query 是使用 <literal>*</literal> 来查询的，可能获得超过列出的这三个字段，也仅仅会返回这三个字段。 "
#. Tag: para
#, no-c-format
-msgid ""
-"It is possible to leave out the type information for all or some of the "
-"scalars."
+msgid "It is possible to leave out the type information for all or some of the scalars."
msgstr "对全部或者部分的标量值不设置类型信息也是可以的。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This is essentially the same query as before, but now "
-"<literal>ResultSetMetaData</literal> is used to determine the type of NAME "
-"and BIRTHDATE, where as the type of ID is explicitly specified."
-msgstr ""
-"基本上这和前面一个查询相同,只是此时使用 <literal>ResultSetMetaData</literal> "
-"来决定 NAME 和 BIRTHDATE 的类型，而 ID 的类型是明确指出的。"
+#, no-c-format
+msgid "This is essentially the same query as before, but now <literal>ResultSetMetaData</literal> is used to determine the type of NAME and BIRTHDATE, where as the type of ID is explicitly specified."
+msgstr "基本上这和前面一个查询相同,只是此时使用 <literal>ResultSetMetaData</literal> 来决定 NAME 和 BIRTHDATE 的类型，而 ID 的类型是明确指出的。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"How the java.sql.Types returned from ResultSetMetaData is mapped to "
-"Hibernate types is controlled by the Dialect. If a specific type is not "
-"mapped, or does not result in the expected type, it is possible to customize "
-"it via calls to <literal>registerHibernateType</literal> in the Dialect."
-msgstr ""
-"关于从 ResultSetMetaData 返回的 java.sql.Types 是如何映射到 Hibernate 类型，"
-"是由方言（Dialect）控制的。假若某个指定的类型没有被映射，或者不是你所预期的类"
-"型，你可以通过 Dialet 的 <literal>registerHibernateType</literal> 调用自行定"
-"义。"
+#, no-c-format
+msgid "How the java.sql.Types returned from ResultSetMetaData is mapped to Hibernate types is controlled by the Dialect. If a specific type is not mapped, or does not result in the expected type, it is possible to customize it via calls to <literal>registerHibernateType</literal> in the Dialect."
+msgstr "关于从 ResultSetMetaData 返回的 java.sql.Types 是如何映射到 Hibernate 类型，是由方言（Dialect）控制的。假若某个指定的类型没有被映射，或者不是你所预期的类型，你可以通过 Dialet 的 <literal>registerHibernateType</literal> 调用自行定义。 "
#. Tag: title
#, no-c-format
@@ -157,14 +101,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The above queries were all about returning scalar values, basically "
-"returning the \"raw\" values from the resultset. The following shows how to "
-"get entity objects from a native sql query via <literal>addEntity()</"
-"literal>."
-msgstr ""
-"上面的查询都是返回标量值的，也就是从 resultset 中返回的“裸”数据。下面展示如何"
-"通过 <literal>addEntity()</literal> 让原生查询返回实体对象。"
+msgid "The above queries were all about returning scalar values, basically returning the \"raw\" values from the resultset. The following shows how to get entity objects from a native sql query via <literal>addEntity()</literal>."
+msgstr "上面的查询都是返回标量值的，也就是从 resultset 中返回的“裸”数据。下面展示如何通过 <literal>addEntity()</literal> 让原生查询返回实体对象。"
#. Tag: para
#, no-c-format
@@ -173,29 +111,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Assuming that Cat is mapped as a class with the columns ID, NAME and "
-"BIRTHDATE the above queries will both return a List where each element is a "
-"Cat entity."
-msgstr ""
-"假设 Cat 被映射为拥有 ID，NAME 和 BIRTHDATE 三个字段的类，以上的两个查询都返"
-"回一个 List，每个元素都是一个 Cat 实体。"
+msgid "Assuming that Cat is mapped as a class with the columns ID, NAME and BIRTHDATE the above queries will both return a List where each element is a Cat entity."
+msgstr "假设 Cat 被映射为拥有 ID，NAME 和 BIRTHDATE 三个字段的类，以上的两个查询都返回一个 List，每个元素都是一个 Cat 实体。"
#. Tag: para
#, no-c-format
-msgid ""
-"If the entity is mapped with a <literal>many-to-one</literal> to another "
-"entity it is required to also return this when performing the native query, "
-"otherwise a database specific \"column not found\" error will occur. The "
-"additional columns will automatically be returned when using the * notation, "
-"but we prefer to be explicit as in the following example for a <literal>many-"
-"to-one</literal> to a <literal>Dog</literal>:"
-msgstr ""
-"假若实体在映射时有一个 <literal>many-to-one</literal> 的关联指向另外一个实"
-"体，在查询时必须也返回那个实体，否则会导致发生一个 \"column not found\" 的数"
-"据库错误。这些附加的字段可以使用 * 标注来自动返回，但我们希望还是明确指明，看"
-"下面这个具有指向 <literal>Dog</literal> 的 <literal>many-to-one</literal> 的"
-"例子："
+msgid "If the entity is mapped with a <literal>many-to-one</literal> to another entity it is required to also return this when performing the native query, otherwise a database specific \"column not found\" error will occur. The additional columns will automatically be returned when using the * notation, but we prefer to be explicit as in the following example for a <literal>many-to-one</literal> to a <literal>Dog</literal>:"
+msgstr "假若实体在映射时有一个 <literal>many-to-one</literal> 的关联指向另外一个实体，在查询时必须也返回那个实体，否则会导致发生一个 \"column not found\" 的数据库错误。这些附加的字段可以使用 * 标注来自动返回，但我们希望还是明确指明，看下面这个具有指向 <literal>Dog</literal> 的 <literal>many-to-one</literal> 的例子："
#. Tag: para
#, no-c-format
@@ -209,43 +131,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"It is possible to eagerly join in the <literal>Dog</literal> to avoid the "
-"possible extra roundtrip for initializing the proxy. This is done via the "
-"<literal>addJoin()</literal> method, which allows you to join in an "
-"association or collection."
-msgstr ""
-"通过提前抓取将 <literal>Dog</literal> 连接获得，而避免初始化 proxy 带来的额外"
-"开销也是可能的。这是通过 <literal>addJoin()</literal> 方法进行的，这个方法可"
-"以让你将关联或集合连接进来。"
+msgid "It is possible to eagerly join in the <literal>Dog</literal> to avoid the possible extra roundtrip for initializing the proxy. This is done via the <literal>addJoin()</literal> method, which allows you to join in an association or collection."
+msgstr "通过提前抓取将 <literal>Dog</literal> 连接获得，而避免初始化 proxy 带来的额外开销也是可能的。这是通过 <literal>addJoin()</literal> 方法进行的，这个方法可以让你将关联或集合连接进来。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"In this example, the returned <literal>Cat</literal>'s will have their "
-"<literal>dog</literal> property fully initialized without any extra "
-"roundtrip to the database. Notice that you added an alias name (\"cat\") to "
-"be able to specify the target property path of the join. It is possible to "
-"do the same eager joining for collections, e.g. if the <literal>Cat</"
-"literal> had a one-to-many to <literal>Dog</literal> instead."
-msgstr ""
-"上面这个例子中，返回的 <literal>Cat</literal> 对象，其 <literal>dog</"
-"literal> 属性被完全初始化了，不再需要数据库的额外操作。注意，我们加了一个别名"
-"（\"cat\"），以便指明 join 的目标属性路径。通过同样的提前连接也可以作用于集合"
-"类，例如，假若 <literal>Cat</literal> 有一个指向 <literal>Dog</literal> 的一"
-"对多关联。"
+#, no-c-format
+msgid "In this example, the returned <literal>Cat</literal>'s will have their <literal>dog</literal> property fully initialized without any extra roundtrip to the database. Notice that you added an alias name (\"cat\") to be able to specify the target property path of the join. It is possible to do the same eager joining for collections, e.g. if the <literal>Cat</literal> had a one-to-many to <literal>Dog</literal> instead."
+msgstr "上面这个例子中，返回的 <literal>Cat</literal> 对象，其 <literal>dog</literal> 属性被完全初始化了，不再需要数据库的额外操作。注意，我们加了一个别名（\"cat\"），以便指明 join 的目标属性路径。通过同样的提前连接也可以作用于集合类，例如，假若 <literal>Cat</literal> 有一个指向 <literal>Dog</literal> 的一对多关联。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"At this stage you are reaching the limits of what is possible with native "
-"queries, without starting to enhance the sql queries to make them usable in "
-"Hibernate. Problems can arise when returning multiple entities of the same "
-"type or when the default alias/column names are not enough."
-msgstr ""
-"到此为止，我们碰到了天花板：若不对 SQL 查询进行增强，这些已经是在 Hibernate "
-"中使用原生 SQL 查询所能做到的最大可能了。下面的问题即将出现：返回多个同样类型"
-"的实体怎么办？或者默认的别名／字段不够又怎么办？"
+#, no-c-format
+msgid "At this stage you are reaching the limits of what is possible with native queries, without starting to enhance the sql queries to make them usable in Hibernate. Problems can arise when returning multiple entities of the same type or when the default alias/column names are not enough."
+msgstr "到此为止，我们碰到了天花板：若不对 SQL 查询进行增强，这些已经是在 Hibernate 中使用原生 SQL 查询所能做到的最大可能了。下面的问题即将出现：返回多个同样类型的实体怎么办？或者默认的别名／字段不够又怎么办？ "
#. Tag: title
#, no-c-format
@@ -253,37 +150,19 @@
msgstr "返回多个实体（Returning multiple entities）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Until now, the result set column names are assumed to be the same as the "
-"column names specified in the mapping document. This can be problematic for "
-"SQL queries that join multiple tables, since the same column names can "
-"appear in more than one table."
-msgstr ""
-"到目前为止,结果集字段名被假定为和映射文件中指定的的字段名是一致的。假若 SQL "
-"查询连接了多个表，同一个字段名可能在多个表中出现多次，这就会造成问题。"
+#, no-c-format
+msgid "Until now, the result set column names are assumed to be the same as the column names specified in the mapping document. This can be problematic for SQL queries that join multiple tables, since the same column names can appear in more than one table."
+msgstr "到目前为止,结果集字段名被假定为和映射文件中指定的的字段名是一致的。假若 SQL 查询连接了多个表，同一个字段名可能在多个表中出现多次，这就会造成问题。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Column alias injection is needed in the following query (which most likely "
-"will fail):"
+msgid "Column alias injection is needed in the following query (which most likely will fail):"
msgstr "下面的查询中需要使用字段别名注射（这个例子本身会失败）："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The query was intended to return two Cat instances per row: a cat and its "
-"mother. The query will, however, fail because there is a conflict of names; "
-"the instances are mapped to the same column names. Also, on some databases "
-"the returned column aliases will most likely be on the form \"c.ID\", \"c."
-"NAME\", etc. which are not equal to the columns specified in the mappings "
-"(\"ID\" and \"NAME\")."
-msgstr ""
-"这个查询的本意是希望每行返回两个 Cat 实例，一个是 cat,另一个是它的妈妈。但是"
-"因为它们的字段名被映射为相同的，而且在某些数据库中，返回的字段别名是“c.ID”，"
-"\"c.NAME\" 这样的形式，而它们和在映射文件中的名字（\"ID\" 和 \"NAME\"）不匹"
-"配，这就会造成失败。"
+#, no-c-format
+msgid "The query was intended to return two Cat instances per row: a cat and its mother. The query will, however, fail because there is a conflict of names; the instances are mapped to the same column names. Also, on some databases the returned column aliases will most likely be on the form \"c.ID\", \"c.NAME\", etc. which are not equal to the columns specified in the mappings (\"ID\" and \"NAME\")."
+msgstr "这个查询的本意是希望每行返回两个 Cat 实例，一个是 cat,另一个是它的妈妈。但是因为它们的字段名被映射为相同的，而且在某些数据库中，返回的字段别名是“c.ID”，\"c.NAME\" 这样的形式，而它们和在映射文件中的名字（\"ID\" 和 \"NAME\"）不匹配，这就会造成失败。 "
#. Tag: para
#, no-c-format
@@ -292,9 +171,7 @@
#. Tag: para
#, no-c-format
-msgid ""
-"the SQL query string, with placeholders for Hibernate to inject column "
-"aliases"
+msgid "the SQL query string, with placeholders for Hibernate to inject column aliases"
msgstr "SQL 查询语句，其中包含占位附来让 Hibernate 注射字段别名"
#. Tag: para
@@ -303,21 +180,9 @@
msgstr "查询返回的实体"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The {cat.*} and {mother.*} notation used above is a shorthand for \"all "
-"properties\". Alternatively, you can list the columns explicitly, but even "
-"in this case Hibernate injects the SQL column aliases for each property. The "
-"placeholder for a column alias is just the property name qualified by the "
-"table alias. In the following example, you retrieve Cats and their mothers "
-"from a different table (cat_log) to the one declared in the mapping "
-"metadata. You can even use the property aliases in the where clause."
-msgstr ""
-"上面使用的 {cat.*} 和 {mother.*} 标记是作为“所有属性”的简写形式出现的。当然你"
-"也可以明确地罗列出字段名，但在这个例子里面我们让 Hibernate 来为每个属性注射 "
-"SQL 字段别名。字段别名的占位符是属性名加上表别名的前缀。在下面的例子中，我们"
-"从另外一个表（cat_log）中通过映射元数据中的指定获取 Cat 和它的妈妈。注意，要"
-"是我们愿意，我们甚至可以在 where 子句中使用属性别名。"
+#, no-c-format
+msgid "The {cat.*} and {mother.*} notation used above is a shorthand for \"all properties\". Alternatively, you can list the columns explicitly, but even in this case Hibernate injects the SQL column aliases for each property. The placeholder for a column alias is just the property name qualified by the table alias. In the following example, you retrieve Cats and their mothers from a different table (cat_log) to the one declared in the mapping metadata. You can even use the property aliases in the where clause."
+msgstr "上面使用的 {cat.*} 和 {mother.*} 标记是作为“所有属性”的简写形式出现的。当然你也可以明确地罗列出字段名，但在这个例子里面我们让 Hibernate 来为每个属性注射 SQL 字段别名。字段别名的占位符是属性名加上表别名的前缀。在下面的例子中，我们从另外一个表（cat_log）中通过映射元数据中的指定获取 Cat 和它的妈妈。注意，要是我们愿意，我们甚至可以在 where 子句中使用属性别名。 "
#. Tag: title
#, no-c-format
@@ -325,27 +190,14 @@
msgstr "别名和属性引用（Alias and property references）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"In most cases the above alias injection is needed. For queries relating to "
-"more complex mappings, like composite properties, inheritance "
-"discriminators, collections etc., you can use specific aliases that allow "
-"Hibernate to inject the proper aliases."
-msgstr ""
-"大多数情况下，都需要上面的属性注射，但在使用更加复杂的映射，比如复合属性、通"
-"过标识符构造继承树，以及集合类等等情况下，也有一些特别的别名，来允许 "
-"Hibernate 注射合适的别名。"
+#, no-c-format
+msgid "In most cases the above alias injection is needed. For queries relating to more complex mappings, like composite properties, inheritance discriminators, collections etc., you can use specific aliases that allow Hibernate to inject the proper aliases."
+msgstr "大多数情况下，都需要上面的属性注射，但在使用更加复杂的映射，比如复合属性、通过标识符构造继承树，以及集合类等等情况下，也有一些特别的别名，来允许 Hibernate 注入合适的别名。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The following table shows the different ways you can use the alias "
-"injection. Please note that the alias names in the result are simply "
-"examples; each alias will have a unique and probably different name when "
-"used."
-msgstr ""
-"下表列出了使用别名注射参数的不同可能性。注意：下面结果中的别名只是示例，实用"
-"时每个别名需要唯一并且不同的名字。"
+#, no-c-format
+msgid "The following table shows the different ways you can use the alias injection. Please note that the alias names in the result are simply examples; each alias will have a unique and probably different name when used."
+msgstr "下表列出了使用别名注射参数的不同可能性。注意：下面结果中的别名只是示例，实用时每个别名需要唯一并且不同的名字。 "
#. Tag: title
#, no-c-format
@@ -373,14 +225,14 @@
msgstr "简单属性"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].[propertyname]</literal>"
-msgstr "{[aliasname].[propertyname]"
+msgstr "<literal>{[aliasname].[propertyname]</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>A_NAME as {item.name}</literal>"
-msgstr "A_NAME as {item.name}"
+msgstr "<literal>A_NAME as {item.name}</literal>"
#. Tag: entry
#, no-c-format
@@ -388,16 +240,14 @@
msgstr "复合属性"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].[componentname].[propertyname]}</literal>"
-msgstr "{[aliasname].[componentname].[propertyname]}"
+msgstr "<literal>{[aliasname].[componentname].[propertyname]}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
-msgid ""
-"<literal>CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}</"
-"literal>"
-msgstr "CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}"
+#, no-c-format
+msgid "<literal>CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}</literal>"
+msgstr "<literal>CURRENCY as {item.amount.currency}, VALUE as {item.amount.value}</literal>"
#. Tag: entry
#, no-c-format
@@ -405,14 +255,14 @@
msgstr "实体辨别器（Discriminator of an entity）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].class}</literal>"
-msgstr "{[aliasname].class}"
+msgstr "<literal>{[aliasname].class}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>DISC as {item.class}</literal>"
-msgstr "DISC as {item.class}"
+msgstr "<literal>DISC as {item.class}</literal>"
#. Tag: entry
#, no-c-format
@@ -420,14 +270,14 @@
msgstr "实体的所有属性"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].*}</literal>"
-msgstr "{[aliasname].*}"
+msgstr "<literal>{[aliasname].*}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{item.*}</literal>"
-msgstr "或存放在一个 <literal>List</literal> 对象中，"
+msgstr "<literal>{item.*}</literal>"
#. Tag: entry
#, no-c-format
@@ -435,14 +285,14 @@
msgstr "集合键（collection key）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].key}</literal>"
-msgstr "{[aliasname].key}"
+msgstr "<literal>{[aliasname].key}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>ORGID as {coll.key}</literal>"
-msgstr "ORGID as {coll.key}"
+msgstr "<literal>ORGID as {coll.key}</literal>"
#. Tag: entry
#, no-c-format
@@ -450,14 +300,14 @@
msgstr "集合 id"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].id}</literal>"
-msgstr "{[aliasname].id}"
+msgstr "<literal>{[aliasname].id}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>EMPID as {coll.id}</literal>"
-msgstr "EMPID as {coll.id}"
+msgstr "<literal>EMPID as {coll.id}</literal>"
#. Tag: entry
#, no-c-format
@@ -465,29 +315,29 @@
msgstr "集合元素"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].element}</literal>"
-msgstr "{[aliasname].element}"
+msgstr "<literal>{[aliasname].element}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>XID as {coll.element}</literal>"
-msgstr "XID as {coll.element}"
+msgstr "<literal>XID as {coll.element}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "property of the element in the collection"
-msgstr "集合元素的属性"
+msgstr "集合元素的属性 "
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].element.[propertyname]}</literal>"
-msgstr "{[aliasname].element.[propertyname]}"
+msgstr "<literal>{[aliasname].element.[propertyname]}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>NAME as {coll.element.name}</literal>"
-msgstr "NAME as {coll.element.name}"
+msgstr "<literal>NAME as {coll.element.name}</literal>"
#. Tag: entry
#, no-c-format
@@ -495,14 +345,14 @@
msgstr "集合元素的所有属性"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{[aliasname].element.*}</literal>"
-msgstr "{[aliasname].element.*}"
+msgstr "<literal>{[aliasname].element.*}</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{coll.element.*}</literal>"
-msgstr "{coll.element.*}"
+msgstr "<literal>{coll.element.*}</literal>"
#. Tag: entry
#, no-c-format
@@ -510,9 +360,9 @@
msgstr "集合的所有属性"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>{coll.*}</literal>"
-msgstr "或存放在一个 <literal>List</literal> 对象中，"
+msgstr "<literal>{coll.*}</literal>"
#. Tag: title
#, no-c-format
@@ -520,13 +370,9 @@
msgstr "返回非受管实体（Returning non-managed entities）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is possible to apply a ResultTransformer to native SQL queries, allowing "
-"it to return non-managed entities."
-msgstr ""
-"可以对原生 sql 查询使用 ResultTransformer。这会返回不受 Hibernate 管理的实"
-"体。"
+#, no-c-format
+msgid "It is possible to apply a ResultTransformer to native SQL queries, allowing it to return non-managed entities."
+msgstr "可以对原生 sql 查询使用 ResultTransformer。这会返回不受 Hibernate 管理的实体。 "
#. Tag: para
#, no-c-format
@@ -535,13 +381,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The above query will return a list of <literal>CatDTO</literal> which has "
-"been instantiated and injected the values of NAME and BIRTHNAME into its "
-"corresponding properties or fields."
-msgstr ""
-"上面的查询将会返回 <literal>CatDTO</literal> 的列表,它将被实例化并且将 NAME "
-"和 BIRTHDAY 的值注射入对应的属性或者字段。"
+msgid "The above query will return a list of <literal>CatDTO</literal> which has been instantiated and injected the values of NAME and BIRTHNAME into its corresponding properties or fields."
+msgstr "上面的查询将会返回 <literal>CatDTO</literal> 的列表,它将被实例化并且将 NAME 和 BIRTHDAY 的值注射入对应的属性或者字段。"
#. Tag: title
#, no-c-format
@@ -549,14 +390,9 @@
msgstr "处理继承（Handling inheritance）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Native SQL queries which query for entities that are mapped as part of an "
-"inheritance must include all properties for the baseclass and all its "
-"subclasses."
-msgstr ""
-"原生 SQL 查询假若其查询结果实体是继承树中的一部分，它必须包含基类和所有子类的"
-"所有属性。"
+#, no-c-format
+msgid "Native SQL queries which query for entities that are mapped as part of an inheritance must include all properties for the baseclass and all its subclasses."
+msgstr "原生 SQL 查询假若其查询结果实体是继承树中的一部分，它必须包含基类和所有子类的所有属性。 "
#. Tag: title
#, no-c-format
@@ -564,9 +400,9 @@
msgstr "参数（Parameters）"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Native SQL queries support positional as well as named parameters:"
-msgstr "原生查询支持位置参数和命名参数："
+msgstr "原生查询支持位置参数和命名参数： "
#. Tag: title
#, no-c-format
@@ -574,54 +410,29 @@
msgstr "命名 SQL 查询"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Named SQL queries can be defined in the mapping document and called in "
-"exactly the same way as a named HQL query. In this case, you do "
-"<emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
-msgstr ""
-"可以在映射文档中定义查询的名字,然后就可以象调用一个命名的 HQL 查询一样直接调"
-"用命名 SQL 查询.在这种情况下，我们<emphasis>不</emphasis> 需要调用 "
-"<literal>addEntity()</literal> 方法。"
+#, no-c-format
+msgid "Named SQL queries can be defined in the mapping document and called in exactly the same way as a named HQL query. In this case, you do <emphasis>not</emphasis> need to call <literal>addEntity()</literal>."
+msgstr "可以在映射文档中定义查询的名字,然后就可以象调用一个命名的 HQL 查询一样直接调用命名 SQL 查询.在这种情况下，我们<emphasis>不</emphasis> 需要调用 <literal>addEntity()</literal> 方法。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal><return-join></literal> element is use to join "
-"associations and the <literal><load-collection></literal> element is "
-"used to define queries which initialize collections,"
-msgstr ""
-"<literal><return-join></literal> 和 <literal><load-collection></"
-"literal> 元素是用来连接关联以及将查询定义为预先初始化各个集合的。"
+#, no-c-format
+msgid "The <literal><return-join></literal> element is use to join associations and the <literal><load-collection></literal> element is used to define queries which initialize collections,"
+msgstr "<literal><return-join></literal> 和 <literal><load-collection></literal> 元素是用来连接关联以及将查询定义为预先初始化各个集合的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"A named SQL query may return a scalar value. You must declare the column "
-"alias and Hibernate type using the <literal><return-scalar></literal> "
-"element:"
-msgstr ""
-"一个命名查询可能会返回一个标量值。你必须使用 <literal><return-scalar></"
-"literal> 元素来指定字段的别名和 Hibernate 类型："
+msgid "A named SQL query may return a scalar value. You must declare the column alias and Hibernate type using the <literal><return-scalar></literal> element:"
+msgstr "一个命名查询可能会返回一个标量值。你必须使用 <literal><return-scalar></literal> 元素来指定字段的别名和 Hibernate 类型："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can externalize the resultset mapping information in a <literal><"
-"resultset></literal> element which will allow you to either reuse them "
-"across several named queries or through the <literal>setResultSetMapping()</"
-"literal> API."
-msgstr ""
-"你可以把结果集映射的信息放在外部的 <literal><resultset></literal> 元素"
-"中，这样就可以在多个命名查询间，或者通过 <literal>setResultSetMapping()</"
-"literal> API 来访问。"
+#, no-c-format
+msgid "You can externalize the resultset mapping information in a <literal><resultset></literal> element which will allow you to either reuse them across several named queries or through the <literal>setResultSetMapping()</literal> API."
+msgstr "你可以把结果集映射的信息放在外部的 <literal><resultset></literal> 元素中，这样就可以在多个命名查询间，或者通过 <literal>setResultSetMapping()</literal> API 来访问。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can, alternatively, use the resultset mapping information in your hbm "
-"files directly in java code."
-msgstr "另外，你可以在 java 代码中直接使用 hbm 文件中的结果集定义信息。"
+#, no-c-format
+msgid "You can, alternatively, use the resultset mapping information in your hbm files directly in java code."
+msgstr "另外，你可以在 java 代码中直接使用 hbm 文件中的结果集定义信息。 "
#. Tag: title
#, no-c-format
@@ -629,44 +440,24 @@
msgstr "使用 return-property 来明确地指定字段／别名"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You can explicitly tell Hibernate what column aliases to use with "
-"<literal><return-property></literal>, instead of using the <literal>{}"
-"</literal>-syntax to let Hibernate inject its own aliases.For example:"
-msgstr ""
-"使用 <literal><return-property></literal> 你可以明确的告诉 Hibernate 使"
-"用哪些字段别名，这取代了使用 <literal>{}</literal>-语法 来让 Hibernate 注入它"
-"自己的别名。"
+#, no-c-format
+msgid "You can explicitly tell Hibernate what column aliases to use with <literal><return-property></literal>, instead of using the <literal>{}</literal>-syntax to let Hibernate inject its own aliases.For example:"
+msgstr "使用 <literal><return-property></literal> 你可以明确的告诉 Hibernate 使用哪些字段别名，这取代了使用 <literal>{}</literal>-语法 来让 Hibernate 注入它自己的别名。例如："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal><return-property></literal> also works with multiple columns. "
-"This solves a limitation with the <literal>{}</literal>-syntax which cannot "
-"allow fine grained control of multi-column properties."
-msgstr ""
-"<literal><return-property></literal> 也可用于多个字段，它解决了使用 "
-"<literal>{}</literal>-语法不能细粒度控制多个字段的限制。"
+#, no-c-format
+msgid "<literal><return-property></literal> also works with multiple columns. This solves a limitation with the <literal>{}</literal>-syntax which cannot allow fine grained control of multi-column properties."
+msgstr "<literal><return-property></literal> 也可用于多个字段，它解决了使用 <literal>{}</literal>-语法不能细粒度控制多个字段的限制。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"In this example <literal><return-property></literal> was used in "
-"combination with the <literal>{}</literal>-syntax for injection. This allows "
-"users to choose how they want to refer column and properties."
-msgstr ""
-"注意在这个例子中，我们使用了 <literal><return-property></literal> 结合 "
-"<literal>{}</literal> 的注入语法。允许用户来选择如何引用字段以及属性。"
+#, no-c-format
+msgid "In this example <literal><return-property></literal> was used in combination with the <literal>{}</literal>-syntax for injection. This allows users to choose how they want to refer column and properties."
+msgstr "注意在这个例子中，我们使用了 <literal><return-property></literal> 结合 <literal>{}</literal> 的注入语法。允许用户来选择如何引用字段以及属性。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If your mapping has a discriminator you must use <literal><return-"
-"discriminator></literal> to specify the discriminator column."
-msgstr ""
-"如果你映射一个识别器（discriminator），你必须使用 <literal><return-"
-"discriminator></literal> 来指定识别器字段。"
+msgid "If your mapping has a discriminator you must use <literal><return-discriminator></literal> to specify the discriminator column."
+msgstr "如果你映射一个识别器（discriminator），你必须使用 <literal><return-discriminator></literal> 来指定识别器字段。"
#. Tag: title
#, no-c-format
@@ -674,18 +465,9 @@
msgstr "使用存储过程来查询"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate3 provides support for queries via stored procedures and functions. "
-"Most of the following documentation is equivalent for both. The stored "
-"procedure/function must return a resultset as the first out-parameter to be "
-"able to work with Hibernate. An example of such a stored function in Oracle "
-"9 and higher is as follows:"
-msgstr ""
-"Hibernate 3 引入了对存储过程查询（stored procedure）和函数（function）的支"
-"持。以下的说明中，这二者一般都适用。存储过程／函数必须返回一个结果集，作为 "
-"Hibernate 能够使用的第一个外部参数。下面是一个 Oracle9 和更高版本的存储过程例"
-"子。"
+#, no-c-format
+msgid "Hibernate3 provides support for queries via stored procedures and functions. Most of the following documentation is equivalent for both. The stored procedure/function must return a resultset as the first out-parameter to be able to work with Hibernate. An example of such a stored function in Oracle 9 and higher is as follows:"
+msgstr "Hibernate 3 引入了对存储过程查询（stored procedure）和函数（function）的支持。以下的说明中，这二者一般都适用。存储过程／函数必须返回一个结果集，作为 Hibernate 能够使用的第一个外部参数。下面是一个 Oracle9 和更高版本的存储过程例子。 "
#. Tag: para
#, no-c-format
@@ -693,14 +475,9 @@
msgstr "在 Hibernate 里要要使用这个查询，你需要通过命名查询来映射它。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Stored procedures currently only return scalars and entities. <literal><"
-"return-join></literal> and <literal><load-collection></literal> are "
-"not supported."
-msgstr ""
-"注意存储过程当前仅仅返回标量和实体现在。不支持 <literal><return-join></"
-"literal> 和 <literal><load-collection></literal>。"
+#, no-c-format
+msgid "Stored procedures currently only return scalars and entities. <literal><return-join></literal> and <literal><load-collection></literal> are not supported."
+msgstr "注意存储过程当前仅仅返回标量和实体现在。不支持 <literal><return-join></literal> 和 <literal><load-collection></literal>。 "
#. Tag: title
#, no-c-format
@@ -708,39 +485,19 @@
msgstr "使用存储过程的规则和限制"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You cannot use stored procedures with Hibernate unless you follow some "
-"procedure/function rules. If they do not follow those rules they are not "
-"usable with Hibernate. If you still want to use these procedures you have to "
-"execute them via <literal>session.connection()</literal>. The rules are "
-"different for each database, since database vendors have different stored "
-"procedure semantics/syntax."
-msgstr ""
-"为了在 Hibernate 中使用存储过程，你必须遵循一些规则。不遵循这些规则的存储过程"
-"将不可用。如果你仍然想使用他们，你必须通过 <literal>session.connection()</"
-"literal> 来执行他们。这些规则针对于不同的数据库。因为数据库提供商有各种不同的"
-"存储过程语法和语义。"
+#, no-c-format
+msgid "You cannot use stored procedures with Hibernate unless you follow some procedure/function rules. If they do not follow those rules they are not usable with Hibernate. If you still want to use these procedures you have to execute them via <literal>session.connection()</literal>. The rules are different for each database, since database vendors have different stored procedure semantics/syntax."
+msgstr "为了在 Hibernate 中使用存储过程，你必须遵循一些规则。不遵循这些规则的存储过程将不可用。如果你仍然想使用他们，你必须通过 <literal>session.connection()</literal> 来执行他们。这些规则针对于不同的数据库。因为数据库提供商有各种不同的存储过程语法和语义。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Stored procedure queries cannot be paged with <literal>setFirstResult()/"
-"setMaxResults()</literal>."
-msgstr ""
-"对存储过程进行的查询无法使用 <literal>setFirstResult()/setMaxResults()</"
-"literal> 进行分页。"
+#, no-c-format
+msgid "Stored procedure queries cannot be paged with <literal>setFirstResult()/setMaxResults()</literal>."
+msgstr "对存储过程进行的查询无法使用 <literal>setFirstResult()/setMaxResults()</literal> 进行分页。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The recommended call form is standard SQL92: <literal>{ ? = call functionName"
-"(<parameters>) }</literal> or <literal>{ ? = call procedureName(<"
-"parameters>}</literal>. Native call syntax is not supported."
-msgstr ""
-"建议采用的调用方式是标准 SQL92: <literal>{ ? = call functionName(<"
-"parameters>) }</literal> 或者 <literal>{ ? = call procedureName(<"
-"parameters>) }</literal>。原生调用语法不被支持。"
+#, no-c-format
+msgid "The recommended call form is standard SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> or <literal>{ ? = call procedureName(<parameters>}</literal>. Native call syntax is not supported."
+msgstr "建议采用的调用方式是标准 SQL92: <literal>{ ? = call functionName(<parameters>) }</literal> 或者 <literal>{ ? = call procedureName(<parameters>) }</literal>。原生调用语法不被支持。 "
#. Tag: para
#, no-c-format
@@ -748,18 +505,9 @@
msgstr "对于 Oracle 有如下规则："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A function must return a result set. The first parameter of a procedure must "
-"be an <literal>OUT</literal> that returns a result set. This is done by "
-"using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle "
-"you need to define a <literal>REF CURSOR</literal> type. See Oracle "
-"literature for further information."
-msgstr ""
-"函数必须返回一个结果集。存储过程的第一个参数必须是 <literal>OUT</literal>，它"
-"返回一个结果集。这是通过 Oracle 9 或 10 的 <literal>SYS_REFCURSOR</literal> "
-"类型来完成的。在 Oracle 中你需要定义一个 <literal>REF CURSOR</literal> 类型，"
-"参见 Oracle 的手册。"
+#, no-c-format
+msgid "A function must return a result set. The first parameter of a procedure must be an <literal>OUT</literal> that returns a result set. This is done by using a <literal>SYS_REFCURSOR</literal> type in Oracle 9 or 10. In Oracle you need to define a <literal>REF CURSOR</literal> type. See Oracle literature for further information."
+msgstr "函数必须返回一个结果集。存储过程的第一个参数必须是 <literal>OUT</literal>，它返回一个结果集。这是通过 Oracle 9 或 10 的 <literal>SYS_REFCURSOR</literal> 类型来完成的。在 Oracle 中你需要定义一个 <literal>REF CURSOR</literal> 类型，参见 Oracle 的手册。 "
#. Tag: para
#, no-c-format
@@ -767,24 +515,14 @@
msgstr "对于 Sybase 或者 MS SQL server 有如下规则："
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The procedure must return a result set. Note that since these servers can "
-"return multiple result sets and update counts, Hibernate will iterate the "
-"results and take the first result that is a result set as its return value. "
-"Everything else will be discarded."
-msgstr ""
-"存储过程必须返回一个结果集。注意这些 servers 可能返回多个结果集以及更新的数"
-"目。Hibernate 将取出第一条结果集作为它的返回值，其他将被丢弃。"
+#, no-c-format
+msgid "The procedure must return a result set. Note that since these servers can return multiple result sets and update counts, Hibernate will iterate the results and take the first result that is a result set as its return value. Everything else will be discarded."
+msgstr "存储过程必须返回一个结果集。注意这些 servers 可能返回多个结果集以及更新的数目。Hibernate 将取出第一条结果集作为它的返回值，其他将被丢弃。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it "
-"will probably be more efficient, but this is not a requirement."
-msgstr ""
-"如果你能够在存储过程里设定 <literal>SET NOCOUNT ON</literal>，这可能会效率更"
-"高，但这不是必需的。"
+msgid "If you can enable <literal>SET NOCOUNT ON</literal> in your procedure it will probably be more efficient, but this is not a requirement."
+msgstr "如果你能够在存储过程里设定 <literal>SET NOCOUNT ON</literal>，这可能会效率更高，但这不是必需的。"
#. Tag: title
#, no-c-format
@@ -793,70 +531,33 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate3 can use custom SQL statements for create, update, and delete "
-"operations. The class and collection persisters in Hibernate already contain "
-"a set of configuration time generated strings (insertsql, deletesql, "
-"updatesql etc.). The mapping tags <literal><sql-insert></literal>, "
-"<literal><sql-delete></literal>, and <literal><sql-update></"
-"literal> override these strings:"
-msgstr ""
-"Hibernate3 能够使用定制的 SQL 语句来执行 create，update 和 delete 操作。在 "
-"Hibernate 中，持久化的类和集合已经包含了一套配置期产生的语句（insertsql，"
-"deletesql，updatesql 等等），这些映射标记 <literal><sql-insert></"
-"literal>，<literal><sql-delete></literal> 和 <literal><sql-"
-"update></literal> 重载了这些语句。"
+msgid "Hibernate3 can use custom SQL statements for create, update, and delete operations. The class and collection persisters in Hibernate already contain a set of configuration time generated strings (insertsql, deletesql, updatesql etc.). The mapping tags <literal><sql-insert></literal>, <literal><sql-delete></literal>, and <literal><sql-update></literal> override these strings:"
+msgstr "Hibernate3 能够使用定制的 SQL 语句来执行 create，update 和 delete 操作。在 Hibernate 中，持久化的类和集合已经包含了一套配置期产生的语句（insertsql，deletesql，updatesql 等等），这些映射标记 <literal><sql-insert></literal>，<literal><sql-delete></literal> 和 <literal><sql-update></literal> 重载了这些语句。"
#. Tag: para
#, fuzzy, 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 直接在你的数据库里执行，所以你可以自由的使用你喜欢的任意语法。但如果"
-"你使用数据库特定的语法，这当然会降低你映射的可移植性。"
+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 直接在你的数据库里执行，所以你可以自由的使用你喜欢的任意语法。但如果你使用数据库特定的语法，这当然会降低你映射的可移植性。"
#. Tag: para
#, no-c-format
-msgid ""
-"Stored procedures are supported if the <literal>callable</literal> attribute "
-"is set:"
+msgid "Stored procedures are supported if the <literal>callable</literal> attribute is set:"
msgstr "如果设定 <literal>callable</literal>，则能够支持存储过程了。"
#. Tag: para
#, fuzzy, no-c-format
-msgid ""
-"The order of the positional parameters is vital, as they must be in the same "
-"sequence as Hibernate expects them."
+msgid "The order of the positional parameters is vital, as they must be in the same sequence as Hibernate expects them."
msgstr "参数的位置顺序是非常重要的，他们必须和 Hibernate 所期待的顺序相同。"
#. Tag: para
#, fuzzy, 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。）"
+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。）"
#. Tag: para
#, fuzzy, 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 操作的语"
-"句的第一个参数注册为一个数值型输出参数。"
+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 操作的语句的第一个参数注册为一个数值型输出参数。"
#. Tag: title
#, no-c-format
@@ -870,9 +571,7 @@
#. Tag: para
#, fuzzy, no-c-format
-msgid ""
-"This is just a named query declaration, as discussed earlier. You can "
-"reference this named query in a class mapping:"
+msgid "This is just a named query declaration, as discussed earlier. You can reference this named query in a class mapping:"
msgstr "这只是一个前面讨论过的命名查询声明，你可以在类映射里引用这个命名查询。"
#. Tag: para
@@ -887,9 +586,7 @@
#. Tag: para
#, fuzzy, no-c-format
-msgid ""
-"You can also define an entity loader that loads a collection by join "
-"fetching:"
+msgid "You can also define an entity loader that loads a collection by join fetching:"
msgstr "你甚至还可以定义一个实体装载器，它通过连接抓取装载一个集合："
#, fuzzy
@@ -1022,10 +719,8 @@
#~ "List loggedCats = sess.createSQLQuery(sql)\n"
#~ " .addEntity(\"cat\", Cat.class)\n"
#~ " .addEntity(\"mother\", Cat.class).list()"
-
#~ msgid "{item.*}"
#~ msgstr "{item.*}"
-
#~ msgid "{coll.*}"
#~ msgstr "{coll.*}"
@@ -1496,3 +1191,4 @@
#~ " ON pers.ID = emp.PERSON_ID\n"
#~ " WHERE ID=?\n"
#~ "</sql-query>"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/session_api.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/session_api.po 2009-12-04 04:13:58 UTC (rev 97440)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/session_api.po 2009-12-04 05:22:06 UTC (rev 97441)
@@ -7,7 +7,7 @@
"Project-Id-Version: session_api\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-12-03T00:15:27\n"
-"PO-Revision-Date: 2009-11-10 10:14+1000\n"
+"PO-Revision-Date: 2009-12-04 14:00+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,31 +22,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate is a full object/relational mapping solution that not only shields "
-"the developer from the details of the underlying database management system, "
-"but also offers <emphasis>state management</emphasis> of objects. This is, "
-"contrary to the management of SQL <literal>statements</literal> in common "
-"JDBC/SQL persistence layers, a natural object-oriented view of persistence "
-"in Java applications."
-msgstr ""
-"Hibernate 是完整的对象/关系映射解决方案，它提供了对象<emphasis>状态管理"
-"（state management）</emphasis>的功能，使开发者不再需要理会底层数据库系统的细"
-"节。也就是说，相对于常见的 JDBC/SQL 持久层方案中需要<literal>管理 SQL 语句</"
-"literal>，Hibernate 采用了更自然的面向对象的视角来持久化 Java 应用中的数据。 "
+msgid "Hibernate is a full object/relational mapping solution that not only shields the developer from the details of the underlying database management system, but also offers <emphasis>state management</emphasis> of objects. This is, contrary to the management of SQL <literal>statements</literal> in common JDBC/SQL persistence layers, a natural object-oriented view of persistence in Java applications."
+msgstr "Hibernate 是完整的对象/关系映射解决方案，它提供了对象<emphasis>状态管理（state management）</emphasis>的功能，使开发者不再需要理会底层数据库系统的细节。也就是说，相对于常见的 JDBC/SQL 持久层方案中需要<literal>管理 SQL 语句</literal>，Hibernate 采用了更自然的面向对象的视角来持久化 Java 应用中的数据。 "
#. Tag: para
#, no-c-format
-msgid ""
-"In other words, Hibernate application developers should always think about "
-"the <emphasis>state</emphasis> of their objects, and not necessarily about "
-"the execution of SQL statements. This part is taken care of by Hibernate and "
-"is only relevant for the application developer when tuning the performance "
-"of the system."
-msgstr ""
-"换句话说，使用 Hibernate 的开发者应该总是关注对象的<emphasis>状态（state）</"
-"emphasis>，不必考虑 SQL 语句的执行。这部分细节已经由 Hibernate 掌管妥当，只有"
-"开发者在进行系统性能调优的时候才需要进行了解。"
+msgid "In other words, Hibernate application developers should always think about the <emphasis>state</emphasis> of their objects, and not necessarily about the execution of SQL statements. This part is taken care of by Hibernate and is only relevant for the application developer when tuning the performance of the system."
+msgstr "换句话说，使用 Hibernate 的开发者应该总是关注对象的<emphasis>状态（state）</emphasis>，不必考虑 SQL 语句的执行。这部分细节已经由 Hibernate 掌管妥当，只有开发者在进行系统性能调优的时候才需要进行了解。"
#. Tag: title
#, no-c-format
@@ -60,76 +42,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Transient</emphasis> - an object is transient if it has just been "
-"instantiated using the <literal>new</literal> operator, and it is not "
-"associated with a Hibernate <literal>Session</literal>. It has no persistent "
-"representation in the database and no identifier value has been assigned. "
-"Transient instances will be destroyed by the garbage collector if the "
-"application does not hold a reference anymore. Use the Hibernate "
-"<literal>Session</literal> to make an object persistent (and let Hibernate "
-"take care of the SQL statements that need to be executed for this "
-"transition)."
-msgstr ""
-"<emphasis>瞬时（Transient）</emphasis> — 由 <literal>new</literal> 操作符创"
-"建，且尚未与Hibernate <literal>Session</literal> 关联的对象被认定为瞬时"
-"（Transient）的。瞬时（Transient）对象不会被持久化到数据库中，也不会被赋予持"
-"久化标识（identifier）。 如果瞬时（Transient）对象在程序中没有被引用，它会被"
-"垃圾回收器（garbage collector）销毁。 使用 Hibernate <literal>Session</"
-"literal>可以将其变为持久（Persistent）状态。（Hibernate会自动执行必要的SQL语"
-"句） "
+msgid "<emphasis>Transient</emphasis> - an object is transient if it has just been instantiated using the <literal>new</literal> operator, and it is not associated with a Hibernate <literal>Session</literal>. It has no persistent representation in the database and no identifier value has been assigned. Transient instances will be destroyed by the garbage collector if the application does not hold a reference anymore. Use the Hibernate <literal>Session</literal> to make an object persistent (and let Hibernate take care of the SQL statements that need to be executed for this transition)."
+msgstr "<emphasis>瞬时（Transient）</emphasis> — 由 <literal>new</literal> 操作符创建，且尚未与Hibernate <literal>Session</literal> 关联的对象被认定为瞬时（Transient）的。瞬时（Transient）对象不会被持久化到数据库中，也不会被赋予持久化标识（identifier）。 如果瞬时（Transient）对象在程序中没有被引用，它会被垃圾回收器（garbage collector）销毁。 使用 Hibernate <literal>Session</literal>可以将其变为持久（Persistent）状态。（Hibernate会自动执行必要的SQL语句） "
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Persistent</emphasis> - a persistent instance has a representation "
-"in the database and an identifier value. It might just have been saved or "
-"loaded, however, it is by definition in the scope of a <literal>Session</"
-"literal>. Hibernate will detect any changes made to an object in persistent "
-"state and synchronize the state with the database when the unit of work "
-"completes. Developers do not execute manual <literal>UPDATE</literal> "
-"statements, or <literal>DELETE</literal> statements when an object should be "
-"made transient."
-msgstr ""
-"<emphasis>持久（Persistent）</emphasis> — 持久（Persistent）的实例在数据库中"
-"有对应的记录，并拥有一个持久化标识（identifier）。 持久（Persistent）的实例可"
-"能是刚被保存的，或刚被加载的，无论哪一种，按定义，它存在于相关联的"
-"<literal>Session</literal>作用范围内。 Hibernate会检测到处于持久"
-"（Persistent）状态的对象的任何改动，在当前操作单元（unit of work）执行完毕时"
-"将对象数据（state）与数据库同步（synchronize）。 开发者不需要手动执行"
-"<literal>UPDATE</literal>。将对象从持久（Persistent）状态变成瞬时"
-"（Transient）状态同样也不需要手动执行 <literal>DELETE</literal> 语句。 "
+msgid "<emphasis>Persistent</emphasis> - a persistent instance has a representation in the database and an identifier value. It might just have been saved or loaded, however, it is by definition in the scope of a <literal>Session</literal>. Hibernate will detect any changes made to an object in persistent state and synchronize the state with the database when the unit of work completes. Developers do not execute manual <literal>UPDATE</literal> statements, or <literal>DELETE</literal> statements when an object should be made transient."
+msgstr "<emphasis>持久（Persistent）</emphasis> — 持久（Persistent）的实例在数据库中有对应的记录，并拥有一个持久化标识（identifier）。 持久（Persistent）的实例可能是刚被保存的，或刚被加载的，无论哪一种，按定义，它存在于相关联的<literal>Session</literal>作用范围内。 Hibernate会检测到处于持久（Persistent）状态的对象的任何改动，在当前操作单元（unit of work）执行完毕时将对象数据（state）与数据库同步（synchronize）。 开发者不需要手动执行<literal>UPDATE</literal>。将对象从持久（Persistent）状态变成瞬时（Transient）状态同样也不需要手动执行 <literal>DELETE</literal> 语句。 "
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Detached</emphasis> - a detached instance is an object that has "
-"been persistent, but its <literal>Session</literal> has been closed. The "
-"reference to the object is still valid, of course, and the detached instance "
-"might even be modified in this state. A detached instance can be reattached "
-"to a new <literal>Session</literal> at a later point in time, making it (and "
-"all the modifications) persistent again. This feature enables a programming "
-"model for long running units of work that require user think-time. We call "
-"them <emphasis>application transactions</emphasis>, i.e., a unit of work "
-"from the point of view of the user."
-msgstr ""
-"<emphasis>脱管（Detached）</emphasis> — 与持久（Persistent）对象关联的"
-"<literal>Session</literal>被关闭后，对象就变为脱管（Detached）的。对脱管"
-"（Detached）对象的引用依然有效，对象可继续被修改。脱管（Detached）对象如果重"
-"新关联到某个新的 <literal>Session</literal> 上， 会再次转变为持久"
-"（Persistent）的（在Detached其间的改动将被持久化到数据库）。 这个功能使得一种"
-"编程模型，即中间会给用户思考时间（user think-time）的长时间运行的操作单元"
-"（unit of work）的编程模型成为可能。我们称之为<emphasis>应用程序事务</"
-"emphasis>，即从用户观点看是一个操作单元（unit of work）。 "
+msgid "<emphasis>Detached</emphasis> - a detached instance is an object that has been persistent, but its <literal>Session</literal> has been closed. The reference to the object is still valid, of course, and the detached instance might even be modified in this state. A detached instance can be reattached to a new <literal>Session</literal> at a later point in time, making it (and all the modifications) persistent again. This feature enables a programming model for long running units of work that require user think-time. We call them <emphasis>application transactions</emphasis>, i.e., a unit of work from the point of view of the user."
+msgstr "<emphasis>脱管（Detached）</emphasis> — 与持久（Persistent）对象关联的<literal>Session</literal>被关闭后，对象就变为脱管（Detached）的。对脱管（Detached）对象的引用依然有效，对象可继续被修改。脱管（Detached）对象如果重新关联到某个新的 <literal>Session</literal> 上， 会再次转变为持久（Persistent）的（在Detached其间的改动将被持久化到数据库）。 这个功能使得一种编程模型，即中间会给用户思考时间（user think-time）的长时间运行的操作单元（unit of work）的编程模型成为可能。我们称之为<emphasis>应用程序事务</emphasis>，即从用户观点看是一个操作单元（unit of work）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"We will now discuss the states and state transitions (and the Hibernate "
-"methods that trigger a transition) in more detail."
-msgstr ""
-"接下来我们来细致地讨论下状态（states）及状态间的转换（state transitions）（以"
-"及触发状态转换的 Hibernate 方法）。 "
+msgid "We will now discuss the states and state transitions (and the Hibernate methods that trigger a transition) in more detail."
+msgstr "接下来我们来细致地讨论下状态（states）及状态间的转换（state transitions）（以及触发状态转换的 Hibernate 方法）。 "
#. Tag: title
#, no-c-format
@@ -138,104 +67,38 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Newly instantiated instances of a a persistent class are considered "
-"<emphasis>transient</emphasis> by Hibernate. We can make a transient "
-"instance <emphasis>persistent</emphasis> by associating it with a session:"
-msgstr ""
-"Hibernate 认为持久化类（persistent class）新实例化的对象是<emphasis>瞬时"
-"（Transient）</emphasis>的。我们可通过将瞬时（Transient）对象与 session 关联"
-"而把它变为<emphasis>持久（Persistent）</emphasis>的。"
+msgid "Newly instantiated instances of a a persistent class are considered <emphasis>transient</emphasis> by Hibernate. We can make a transient instance <emphasis>persistent</emphasis> by associating it with a session:"
+msgstr "Hibernate 认为持久化类（persistent class）新实例化的对象是<emphasis>瞬时（Transient）</emphasis>的。我们可通过将瞬时（Transient）对象与 session 关联而把它变为<emphasis>持久（Persistent）</emphasis>的。"
#. Tag: para
#, no-c-format
-msgid ""
-"If <literal>Cat</literal> has a generated identifier, the identifier is "
-"generated and assigned to the <literal>cat</literal> when <literal>save()</"
-"literal> is called. If <literal>Cat</literal> has an <literal>assigned</"
-"literal> identifier, or a composite key, the identifier should be assigned "
-"to the <literal>cat</literal> instance before calling <literal>save()</"
-"literal>. You can also use <literal>persist()</literal> instead of "
-"<literal>save()</literal>, with the semantics defined in the EJB3 early "
-"draft."
-msgstr ""
-"如果 <literal>Cat</literal> 的持久化标识（identifier）是 <literal>generated</"
-"literal> 类型的， 那么该标识（identifier）会自动在 <literal>save()</literal> "
-"被调用时产生并分配给 <literal>cat</literal>。如果 <literal>Cat</literal> 的持"
-"久化标识（identifier）是<literal>assigned</literal>类型的，或是一个复合主键"
-"（composite key），那么该标识（identifier）应当在调用 <literal>save()</"
-"literal> 之前手动赋予给 <literal>cat</literal>。你也可以按照 EJB3 early "
-"draft 中定义的语义，使用 <literal>persist()</literal> 替代<literal>save()</"
-"literal>。 "
+msgid "If <literal>Cat</literal> has a generated identifier, the identifier is generated and assigned to the <literal>cat</literal> when <literal>save()</literal> is called. If <literal>Cat</literal> has an <literal>assigned</literal> identifier, or a composite key, the identifier should be assigned to the <literal>cat</literal> instance before calling <literal>save()</literal>. You can also use <literal>persist()</literal> instead of <literal>save()</literal>, with the semantics defined in the EJB3 early draft."
+msgstr "如果 <literal>Cat</literal> 的持久化标识（identifier）是 <literal>generated</literal> 类型的， 那么该标识（identifier）会自动在 <literal>save()</literal> 被调用时产生并分配给 <literal>cat</literal>。如果 <literal>Cat</literal> 的持久化标识（identifier）是<literal>assigned</literal>类型的，或是一个复合主键（composite key），那么该标识（identifier）应当在调用 <literal>save()</literal> 之前手动赋予给 <literal>cat</literal>。你也可以按照 EJB3 early draft 中定义的语义，使用 <literal>persist()</literal> 替代<literal>save()</literal>。 "
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>persist()</literal> makes a transient instance persistent. However, "
-"it does not guarantee that the identifier value will be assigned to the "
-"persistent instance immediately, the assignment might happen at flush time. "
-"<literal>persist()</literal> also guarantees that it will not execute an "
-"<literal>INSERT</literal> statement if it is called outside of transaction "
-"boundaries. This is useful in long-running conversations with an extended "
-"Session/persistence context."
-msgstr ""
-"<literal>persist()</literal> 使一个临时实例持久化。然而，它不保证立即把标识符"
-"值分配给持久性实例，这会发生在冲刷（flush）的时候。<literal>persist()</"
-"literal> 也保证它在事务边界外调用时不会执行 <literal>INSERT</literal> 语句。"
-"这对于长期运行的带有扩展会话/持久化上下文的会话是很有用的。"
+msgid "<literal>persist()</literal> makes a transient instance persistent. However, it does not guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. <literal>persist()</literal> also guarantees that it will not execute an <literal>INSERT</literal> statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context."
+msgstr "<literal>persist()</literal> 使一个临时实例持久化。然而，它不保证立即把标识符值分配给持久性实例，这会发生在冲刷（flush）的时候。<literal>persist()</literal> 也保证它在事务边界外调用时不会执行 <literal>INSERT</literal> 语句。这对于长期运行的带有扩展会话/持久化上下文的会话是很有用的。"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>save()</literal> does guarantee to return an identifier. If an "
-"INSERT has to be executed to get the identifier ( e.g. \"identity\" "
-"generator, not \"sequence\"), this INSERT happens immediately, no matter if "
-"you are inside or outside of a transaction. This is problematic in a long-"
-"running conversation with an extended Session/persistence context."
-msgstr ""
-"<literal>save()</literal> 保证返回一个标识符。如果需要运行 INSERT 来获取标识"
-"符（如 \"identity\" 而非 \"sequence\" 生成器），这个 INSERT 将立即执行，不管"
-"你是否在事务内部还是外部。这对于长期运行的带有扩展会话/持久化上下文的会话来说"
-"会出现问题。"
+msgid "<literal>save()</literal> does guarantee to return an identifier. If an INSERT has to be executed to get the identifier ( e.g. \"identity\" generator, not \"sequence\"), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is problematic in a long-running conversation with an extended Session/persistence context."
+msgstr "<literal>save()</literal> 保证返回一个标识符。如果需要运行 INSERT 来获取标识符（如 \"identity\" 而非 \"sequence\" 生成器），这个 INSERT 将立即执行，不管你是否在事务内部还是外部。这对于长期运行的带有扩展会话/持久化上下文的会话来说会出现问题。"
#. Tag: para
#, no-c-format
-msgid ""
-"Alternatively, you can assign the identifier using an overloaded version of "
-"<literal>save()</literal>."
+msgid "Alternatively, you can assign the identifier using an overloaded version of <literal>save()</literal>."
msgstr "此外，你可以用一个重载版本的 <literal>save()</literal> 方法。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If the object you make persistent has associated objects (e.g. the "
-"<literal>kittens</literal> collection in the previous example), these "
-"objects can be made persistent in any order you like unless you have a "
-"<literal>NOT NULL</literal> constraint upon a foreign key column. There is "
-"never a risk of violating foreign key constraints. However, you might "
-"violate a <literal>NOT NULL</literal> constraint if you <literal>save()</"
-"literal> the objects in the wrong order."
-msgstr ""
-"如果你持久化的对象有关联的对象（associated objects）（例如上例中的 "
-"<literal>kittens</literal> 集合） 那么对这些对象（译注：pk 和 kittens）进行持"
-"久化的顺序是任意的（也就是说可以先对 kittens 进行持久化也可以先对 pk 进行持久"
-"化）， 除非你在外键列上有 <literal>NOT NULL</literal> 约束。 Hibernate 不会违"
-"反外键约束，但是如果你用错误的顺序持久化对象（译注：在 pk 持久化之前持久化"
-"kitten），那么可能会违反 <literal>NOT NULL</literal> 约束。 "
+msgid "If the object you make persistent has associated objects (e.g. the <literal>kittens</literal> collection in the previous example), these objects can be made persistent in any order you like unless you have a <literal>NOT NULL</literal> constraint upon a foreign key column. There is never a risk of violating foreign key constraints. However, you might violate a <literal>NOT NULL</literal> constraint if you <literal>save()</literal> the objects in the wrong order."
+msgstr "如果你持久化的对象有关联的对象（associated objects）（例如上例中的 <literal>kittens</literal> 集合） 那么对这些对象（译注：pk 和 kittens）进行持久化的顺序是任意的（也就是说可以先对 kittens 进行持久化也可以先对 pk 进行持久化）， 除非你在外键列上有 <literal>NOT NULL</literal> 约束。 Hibernate 不会违反外键约束，但是如果你用错误的顺序持久化对象（译注：在 pk 持久化之前持久化kitten），那么可能会违反 <literal>NOT NULL</literal> 约束。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Usually you do not bother with this detail, as you will normally use "
-"Hibernate's <emphasis>transitive persistence</emphasis> feature to save the "
-"associated objects automatically. Then, even <literal>NOT NULL</literal> "
-"constraint violations do not occur - Hibernate will take care of everything. "
-"Transitive persistence is discussed later in this chapter."
-msgstr ""
-"通常你不会为这些细节烦心，因为你很可能会使用 Hibernate 的<emphasis>传播性持久"
-"化（transitive persistence）</emphasis>功能自动保存相关联那些对象。这样连违"
-"反 <literal>NOT NULL</literal> 约束的情况都不会出现了 — Hibernate 会管好所有"
-"的事情。传播性持久化（transitive persistence）将在本章稍后讨论。"
+msgid "Usually you do not bother with this detail, as you will normally use Hibernate's <emphasis>transitive persistence</emphasis> feature to save the associated objects automatically. Then, even <literal>NOT NULL</literal> constraint violations do not occur - Hibernate will take care of everything. Transitive persistence is discussed later in this chapter."
+msgstr "通常你不会为这些细节烦心，因为你很可能会使用 Hibernate 的<emphasis>传播性持久化（transitive persistence）</emphasis>功能自动保存相关联那些对象。这样连违反 <literal>NOT NULL</literal> 约束的情况都不会出现了 — Hibernate 会管好所有的事情。传播性持久化（transitive persistence）将在本章稍后讨论。"
#. Tag: title
#, no-c-format
@@ -244,100 +107,43 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>load()</literal> methods of <literal>Session</literal> provide "
-"a way of retrieving a persistent instance if you know its identifier. "
-"<literal>load()</literal> takes a class object and loads the state into a "
-"newly instantiated instance of that class in a persistent state."
-msgstr ""
-"如果你知道某个实例的持久化标识（identifier），你就可以使用 <literal>Session</"
-"literal> 的 <literal>load()</literal> 方法来获取它。<literal>load()</"
-"literal> 的另一个参数是指定类的对象。本方法会创建指定类的持久化实例，并从数据"
-"库加载其数据（state）。 "
+msgid "The <literal>load()</literal> methods of <literal>Session</literal> provide a way of retrieving a persistent instance if you know its identifier. <literal>load()</literal> takes a class object and loads the state into a newly instantiated instance of that class in a persistent state."
+msgstr "如果你知道某个实例的持久化标识（identifier），你就可以使用 <literal>Session</literal> 的 <literal>load()</literal> 方法来获取它。<literal>load()</literal> 的另一个参数是指定类的对象。本方法会创建指定类的持久化实例，并从数据库加载其数据（state）。 "
#. Tag: para
#, no-c-format
msgid "Alternatively, you can load state into a given instance:"
-msgstr ""
-"此外，你可以把数据（state）加载到指定的对象实例上（覆盖掉该实例原来的数据）。"
+msgstr "此外，你可以把数据（state）加载到指定的对象实例上（覆盖掉该实例原来的数据）。"
#. Tag: para
#, no-c-format
-msgid ""
-"Be aware that <literal>load()</literal> will throw an unrecoverable "
-"exception if there is no matching database row. If the class is mapped with "
-"a proxy, <literal>load()</literal> just returns an uninitialized proxy and "
-"does not actually hit the database until you invoke a method of the proxy. "
-"This is useful if you wish to create an association to an object without "
-"actually loading it from the database. It also allows multiple instances to "
-"be loaded as a batch if <literal>batch-size</literal> is defined for the "
-"class mapping."
-msgstr ""
-"请注意如果没有匹配的数据库记录，<literal>load()</literal> 方法可能抛出无法恢"
-"复的异常（unrecoverable exception）。如果类的映射使用了代理（proxy），"
-"<literal>load()</literal> 方法会返回一个未初始化的代理，直到你调用该代理的某"
-"方法时才会去访问数据库。 若你希望在某对象中创建一个指向另一个对象的关联，又不"
-"想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上"
-"的了。如果为相应类映射关系设置了 <literal>batch-size</literal>，那么使用这种"
-"操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象"
-"的数据）。 "
+msgid "Be aware that <literal>load()</literal> will throw an unrecoverable exception if there is no matching database row. If the class is mapped with a proxy, <literal>load()</literal> just returns an uninitialized proxy and does not actually hit the database until you invoke a method of the proxy. This is useful if you wish to create an association to an object without actually loading it from the database. It also allows multiple instances to be loaded as a batch if <literal>batch-size</literal> is defined for the class mapping."
+msgstr "请注意如果没有匹配的数据库记录，<literal>load()</literal> 方法可能抛出无法恢复的异常（unrecoverable exception）。如果类的映射使用了代理（proxy），<literal>load()</literal> 方法会返回一个未初始化的代理，直到你调用该代理的某方法时才会去访问数据库。 若你希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上的了。如果为相应类映射关系设置了 <literal>batch-size</literal>，那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象的数据）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If you are not certain that a matching row exists, you should use the "
-"<literal>get()</literal> method which hits the database immediately and "
-"returns null if there is no matching row."
-msgstr ""
-"如果你不确定是否有匹配的行存在，应该使用 <literal>get()</literal> 方法，它会"
-"立刻访问数据库，如果没有对应的记录，会返回 null。 "
+msgid "If you are not certain that a matching row exists, you should use the <literal>get()</literal> method which hits the database immediately and returns null if there is no matching row."
+msgstr "如果你不确定是否有匹配的行存在，应该使用 <literal>get()</literal> 方法，它会立刻访问数据库，如果没有对应的记录，会返回 null。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You can even load an object using an SQL <literal>SELECT ... FOR UPDATE</"
-"literal>, using a <literal>LockMode</literal>. See the API documentation for "
-"more information."
-msgstr ""
-"你甚至可以选用某个 <literal>LockMode</literal>，用 SQL 的 "
-"<literal>SELECT ... FOR UPDATE</literal> 装载对象。 请查阅 API 文档以获取更多"
-"信息。 "
+msgid "You can even load an object using an SQL <literal>SELECT ... FOR UPDATE</literal>, using a <literal>LockMode</literal>. See the API documentation for more information."
+msgstr "你甚至可以选用某个 <literal>LockMode</literal>，用 SQL 的 <literal>SELECT ... FOR UPDATE</literal> 装载对象。 请查阅 API 文档以获取更多信息。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Any associated instances or contained collections will <emphasis>not</"
-"emphasis> be selected <literal>FOR UPDATE</literal>, unless you decide to "
-"specify <literal>lock</literal> or <literal>all</literal> as a cascade style "
-"for the association."
-msgstr ""
-"注意，任何关联的对象或者包含的集合都<emphasis>不会</emphasis>被以 "
-"<literal>FOR UPDATE</literal> 方式返回， 除非你指定了 <literal>lock</"
-"literal> 或者 <literal>all</literal> 作为关联（association）的级联风格"
-"（cascade style）。 "
+msgid "Any associated instances or contained collections will <emphasis>not</emphasis> be selected <literal>FOR UPDATE</literal>, unless you decide to specify <literal>lock</literal> or <literal>all</literal> as a cascade style for the association."
+msgstr "注意，任何关联的对象或者包含的集合都<emphasis>不会</emphasis>被以 <literal>FOR UPDATE</literal> 方式返回， 除非你指定了 <literal>lock</literal> 或者 <literal>all</literal> 作为关联（association）的级联风格（cascade style）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"It is possible to re-load an object and all its collections at any time, "
-"using the <literal>refresh()</literal> method. This is useful when database "
-"triggers are used to initialize some of the properties of the object."
-msgstr ""
-"任何时候都可以使用 <literal>refresh()</literal> 方法强迫装载对象和它的集合。"
-"如果你使用数据库触发器功能来处理对象的某些属性，这个方法就很有用了。"
+msgid "It is possible to re-load an object and all its collections at any time, using the <literal>refresh()</literal> method. This is useful when database triggers are used to initialize some of the properties of the object."
+msgstr "任何时候都可以使用 <literal>refresh()</literal> 方法强迫装载对象和它的集合。如果你使用数据库触发器功能来处理对象的某些属性，这个方法就很有用了。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"How much does Hibernate load from the database and how many SQL "
-"<literal>SELECT</literal>s will it use? This depends on the "
-"<emphasis>fetching strategy</emphasis>. This is explained in <xref linkend="
-"\"performance-fetching\" />."
-msgstr ""
-"此处通常会出现一个重要问题: Hibernate 会从数据库中装载多少东西？会执行多少条"
-"相应的 SQL<literal>SELECT</literal> 语句？这取决于<emphasis>抓取策略"
-"（fetching strategy）</emphasis>，会在 <xref linkend=\"performance-fetching"
-"\"/> 中解释。 "
+#, no-c-format
+msgid "How much does Hibernate load from the database and how many SQL <literal>SELECT</literal>s will it use? This depends on the <emphasis>fetching strategy</emphasis>. This is explained in <xref linkend=\"performance-fetching\" />."
+msgstr "此处通常会出现一个重要问题: Hibernate 会从数据库中装载多少东西？会执行多少条相应的 SQL<literal>SELECT</literal> 语句？这取决于<emphasis>抓取策略（fetching strategy）</emphasis>，我们会在 <xref linkend=\"performance-fetching\" /> 中解释。 "
#. Tag: title
#, no-c-format
@@ -346,19 +152,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If you do not know the identifiers of the objects you are looking for, you "
-"need a query. Hibernate supports an easy-to-use but powerful object oriented "
-"query language (HQL). For programmatic query creation, Hibernate supports a "
-"sophisticated Criteria and Example query feature (QBC and QBE). You can also "
-"express your query in the native SQL of your database, with optional support "
-"from Hibernate for result set conversion into objects."
-msgstr ""
-"如果不知道所要寻找的对象的持久化标识，那么你需要使用查询。Hibernate 支持强大"
-"且易于使用的面向对象查询语言（HQL）。如果希望通过编程的方式创建查询，"
-"Hibernate 提供了完善的按条件（Query By Criteria，QBC）以及按样例（Query By "
-"Example，QBE）进行查询的功能。你也可以用原生 SQL（native SQL）描述查询，"
-"Hibernate 额外提供了将结果集（result set）转化为对象的支持。 "
+msgid "If you do not know the identifiers of the objects you are looking for, you need a query. Hibernate supports an easy-to-use but powerful object oriented query language (HQL). For programmatic query creation, Hibernate supports a sophisticated Criteria and Example query feature (QBC and QBE). You can also express your query in the native SQL of your database, with optional support from Hibernate for result set conversion into objects."
+msgstr "如果不知道所要寻找的对象的持久化标识，那么你需要使用查询。Hibernate 支持强大且易于使用的面向对象查询语言（HQL）。如果希望通过编程的方式创建查询，Hibernate 提供了完善的按条件（Query By Criteria，QBC）以及按样例（Query By Example，QBE）进行查询的功能。你也可以用原生 SQL（native SQL）描述查询，Hibernate 额外提供了将结果集（result set）转化为对象的支持。 "
#. Tag: title
#, no-c-format
@@ -367,36 +162,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"HQL and native SQL queries are represented with an instance of <literal>org."
-"hibernate.Query</literal>. This interface offers methods for parameter "
-"binding, result set handling, and for the execution of the actual query. You "
-"always obtain a <literal>Query</literal> using the current <literal>Session</"
-"literal>:"
-msgstr ""
-"HQL 和原生 SQL（native SQL）查询要通过为 <literal>org.hibernate.Query</"
-"literal> 的实例来表达。 这个接口提供了参数绑定、结果集处理以及运行实际查询的"
-"方法。你总是可以通过当前 <literal>Session</literal> 获取一个 <literal>Query</"
-"literal> 对象："
+msgid "HQL and native SQL queries are represented with an instance of <literal>org.hibernate.Query</literal>. This interface offers methods for parameter binding, result set handling, and for the execution of the actual query. You always obtain a <literal>Query</literal> using the current <literal>Session</literal>:"
+msgstr "HQL 和原生 SQL（native SQL）查询要通过为 <literal>org.hibernate.Query</literal> 的实例来表达。 这个接口提供了参数绑定、结果集处理以及运行实际查询的方法。你总是可以通过当前 <literal>Session</literal> 获取一个 <literal>Query</literal> 对象："
#. Tag: para
#, no-c-format
-msgid ""
-"A query is usually executed by invoking <literal>list()</literal>. The "
-"result of the query will be loaded completely into a collection in memory. "
-"Entity instances retrieved by a query are in a persistent state. The "
-"<literal>uniqueResult()</literal> method offers a shortcut if you know your "
-"query will only return a single object. Queries that make use of eager "
-"fetching of collections usually return duplicates of the root objects, but "
-"with their collections initialized. You can filter these duplicates through "
-"a <literal>Set</literal>."
-msgstr ""
-"一个查询通常在调用 <literal>list()</literal> 时被执行，执行结果会完全装载进内"
-"存中的一个集合（collection）。查询返回的对象处于持久（persistent）状态。如果"
-"你知道的查询只会返回一个对象，可使用 <literal>list()</literal> 的快捷方式 "
-"<literal>uniqueResult()</literal>。注意，使用集合预先抓取的查询往往会返回多次"
-"根对象（他们的集合类都被初始化了）。你可以通过一个<literal>集合（Set）</"
-"literal>来过滤这些重复对象。"
+msgid "A query is usually executed by invoking <literal>list()</literal>. The result of the query will be loaded completely into a collection in memory. Entity instances retrieved by a query are in a persistent state. The <literal>uniqueResult()</literal> method offers a shortcut if you know your query will only return a single object. Queries that make use of eager fetching of collections usually return duplicates of the root objects, but with their collections initialized. You can filter these duplicates through a <literal>Set</literal>."
+msgstr "一个查询通常在调用 <literal>list()</literal> 时被执行，执行结果会完全装载进内存中的一个集合（collection）。查询返回的对象处于持久（persistent）状态。如果你知道的查询只会返回一个对象，可使用 <literal>list()</literal> 的快捷方式 <literal>uniqueResult()</literal>。注意，使用集合预先抓取的查询往往会返回多次根对象（他们的集合类都被初始化了）。你可以通过一个<literal>集合（Set）</literal>来过滤这些重复对象。"
#. Tag: title
#, no-c-format
@@ -405,24 +177,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Occasionally, you might be able to achieve better performance by executing "
-"the query using the <literal>iterate()</literal> method. This will usually "
-"be the case if you expect that the actual entity instances returned by the "
-"query will already be in the session or second-level cache. If they are not "
-"already cached, <literal>iterate()</literal> will be slower than "
-"<literal>list()</literal> and might require many database hits for a simple "
-"query, usually <emphasis>1</emphasis> for the initial select which only "
-"returns identifiers, and <emphasis>n</emphasis> additional selects to "
-"initialize the actual instances."
-msgstr ""
-"某些情况下，你可以使用 <literal>iterate()</literal> 方法得到更好的性能。 这通"
-"常是你预期返回的结果在 session，或二级缓存（second-level cache）中已经存在时"
-"的情况。如若不然，<literal>iterate()</literal> 会比 <literal>list()</"
-"literal> 慢，而且可能简单查询也需要进行多次数据库访问：<literal>iterate()</"
-"literal> 会首先使用 <emphasis>1</emphasis> 条语句得到所有对象的持久化标识"
-"（identifiers），再根据持久化标识执行 <emphasis>n</emphasis> 条附加的 select "
-"语句实例化实际的对象。 "
+msgid "Occasionally, you might be able to achieve better performance by executing the query using the <literal>iterate()</literal> method. This will usually be the case if you expect that the actual entity instances returned by the query will already be in the session or second-level cache. If they are not already cached, <literal>iterate()</literal> will be slower than <literal>list()</literal> and might require many database hits for a simple query, usually <emphasis>1</emphasis> for the initial select which only returns identifiers, and <emphasis>n</emphasis> additional selects to initialize the actual instances."
+msgstr "某些情况下，你可以使用 <literal>iterate()</literal> 方法得到更好的性能。 这通常是你预期返回的结果在 session，或二级缓存（second-level cache）中已经存在时的情况。如若不然，<literal>iterate()</literal> 会比 <literal>list()</literal> 慢，而且可能简单查询也需要进行多次数据库访问：<literal>iterate()</literal> 会首先使用 <emphasis>1</emphasis> 条语句得到所有对象的持久化标识（identifiers），再根据持久化标识执行 <emphasis>n</emphasis> 条附加的 select 语句实例化实际的对象。 "
#. Tag: title
#, no-c-format
@@ -431,12 +187,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate queries sometimes return tuples of objects. Each tuple is returned "
-"as an array:"
-msgstr ""
-"（译注：元组（tuples）指一条结果行包含多个对象） Hibernate 查询有时返回元组"
-"（tuples），每个元组（tuples）以数组的形式返回: "
+msgid "Hibernate queries sometimes return tuples of objects. Each tuple is returned as an array:"
+msgstr "（译注：元组（tuples）指一条结果行包含多个对象） Hibernate 查询有时返回元组（tuples），每个元组（tuples）以数组的形式返回: "
#. Tag: title
#, no-c-format
@@ -445,14 +197,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Queries can specify a property of a class in the <literal>select</literal> "
-"clause. They can even call SQL aggregate functions. Properties or aggregates "
-"are considered \"scalar\" results and not entities in persistent state."
-msgstr ""
-"查询可在 <literal>select</literal> 从句中指定类的属性，甚至可以调用 SQL 统计"
-"（aggregate）函数。属性或统计结果被认定为\"标量（Scalar）\"的结果（而不是持久"
-"（persistent state）的实体）。 "
+msgid "Queries can specify a property of a class in the <literal>select</literal> clause. They can even call SQL aggregate functions. Properties or aggregates are considered \"scalar\" results and not entities in persistent state."
+msgstr "查询可在 <literal>select</literal> 从句中指定类的属性，甚至可以调用 SQL 统计（aggregate）函数。属性或统计结果被认定为\"标量（Scalar）\"的结果（而不是持久（persistent state）的实体）。 "
#. Tag: title
#, no-c-format
@@ -461,23 +207,12 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Methods on <literal>Query</literal> are provided for binding values to named "
-"parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary "
-"to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters "
-"are identifiers of the form <literal>:name</literal> in the query string. "
-"The advantages of named parameters are as follows:"
-msgstr ""
-"接口 <literal>Query</literal> 提供了对命名参数（named parameters）、JDBC 风格"
-"的<literal>问号（?）</literal>参数进行绑定的方法。<emphasis>不同于 JDBC，"
-"Hibernate 对参数从 0 开始计数。</emphasis> 命名参数（named parameters）在查询"
-"字符串中是形如 <literal>:name</literal> 的标识符。命名参数（named "
-"parameters）的优点是： "
+msgid "Methods on <literal>Query</literal> are provided for binding values to named parameters or JDBC-style <literal>?</literal> parameters. <emphasis>Contrary to JDBC, Hibernate numbers parameters from zero.</emphasis> Named parameters are identifiers of the form <literal>:name</literal> in the query string. The advantages of named parameters are as follows:"
+msgstr "接口 <literal>Query</literal> 提供了对命名参数（named parameters）、JDBC 风格的<literal>问号（?）</literal>参数进行绑定的方法。<emphasis>不同于 JDBC，Hibernate 对参数从 0 开始计数。</emphasis> 命名参数（named parameters）在查询字符串中是形如 <literal>:name</literal> 的标识符。命名参数（named parameters）的优点是： "
#. Tag: para
#, no-c-format
-msgid ""
-"named parameters are insensitive to the order they occur in the query string"
+msgid "named parameters are insensitive to the order they occur in the query string"
msgstr "命名参数（named parameters）与其在查询串中出现的顺序无关"
#. Tag: para
@@ -497,22 +232,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If you need to specify bounds upon your result set, that is, the maximum "
-"number of rows you want to retrieve and/or the first row you want to "
-"retrieve, you can use methods of the <literal>Query</literal> interface:"
-msgstr ""
-"如果你需要指定结果集的范围（希望返回的最大行数/或开始的行数），应该使用 "
-"<literal>Query</literal> 接口提供的方法： "
+msgid "If you need to specify bounds upon your result set, that is, the maximum number of rows you want to retrieve and/or the first row you want to retrieve, you can use methods of the <literal>Query</literal> interface:"
+msgstr "如果你需要指定结果集的范围（希望返回的最大行数/或开始的行数），应该使用 <literal>Query</literal> 接口提供的方法： "
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate knows how to translate this limit query into the native SQL of "
-"your DBMS."
-msgstr ""
-"Hibernate 知道如何将这个有限定条件的查询转换成你的数据库的原生 SQL（native "
-"SQL）。"
+msgid "Hibernate knows how to translate this limit query into the native SQL of your DBMS."
+msgstr "Hibernate 知道如何将这个有限定条件的查询转换成你的数据库的原生 SQL（native SQL）。"
#. Tag: title
#, no-c-format
@@ -521,26 +247,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the "
-"<literal>Query</literal> interface can be used to obtain a "
-"<literal>ScrollableResults</literal> object that allows flexible navigation "
-"of the query results."
-msgstr ""
-"如果你的 JDBC 驱动支持可滚动的 <literal>ResuleSet</literal>，<literal>Query</"
-"literal> 接口可以使用 <literal>ScrollableResults</literal>，允许你在查询结果"
-"中灵活游走。 "
+msgid "If your JDBC driver supports scrollable <literal>ResultSet</literal>s, the <literal>Query</literal> interface can be used to obtain a <literal>ScrollableResults</literal> object that allows flexible navigation of the query results."
+msgstr "如果你的 JDBC 驱动支持可滚动的 <literal>ResuleSet</literal>，<literal>Query</literal> 接口可以使用 <literal>ScrollableResults</literal>，允许你在查询结果中灵活游走。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Note that an open database connection and cursor is required for this "
-"functionality. Use <literal>setMaxResult()</literal>/<literal>setFirstResult"
-"()</literal> if you need offline pagination functionality."
-msgstr ""
-"请注意，使用此功能需要保持数据库连接（以及游标（cursor））处于一直打开状态。"
-"如果你需要断开连接使用分页功能，请使用 <literal>setMaxResult()</literal>/"
-"<literal>setFirstResult()</literal>。 "
+msgid "Note that an open database connection and cursor is required for this functionality. Use <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal> if you need offline pagination functionality."
+msgstr "请注意，使用此功能需要保持数据库连接（以及游标（cursor））处于一直打开状态。如果你需要断开连接使用分页功能，请使用 <literal>setMaxResult()</literal>/<literal>setFirstResult()</literal>。 "
#. Tag: title
#, no-c-format
@@ -549,13 +262,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"You can also define named queries in the mapping document. Remember to use a "
-"<literal>CDATA</literal> section if your query contains characters that "
-"could be interpreted as markup."
-msgstr ""
-"你可以在映射文件中定义命名查询（named queries）。如果你的查询串中包含可能被解"
-"释为 XML 标记（markup）的字符，别忘了用<literal>CDATA</literal>包裹起来。"
+msgid "You can also define named queries in the mapping document. Remember to use a <literal>CDATA</literal> section if your query contains characters that could be interpreted as markup."
+msgstr "你可以在映射文件中定义命名查询（named queries）。如果你的查询串中包含可能被解释为 XML 标记（markup）的字符，别忘了用<literal>CDATA</literal>包裹起来。"
#. Tag: para
#, no-c-format
@@ -564,28 +272,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The actual program code is independent of the query language that is used. "
-"You can also define native SQL queries in metadata, or migrate existing "
-"queries to Hibernate by placing them in mapping files."
-msgstr ""
-"请注意实际的程序代码与所用的查询语言无关，你也可在元数据中定义原生 SQL"
-"（native SQL）查询，或将原有的其他的查询语句放在配置文件中，这样就可以让 "
-"Hibernate 统一管理，达到迁移的目的。 "
+msgid "The actual program code is independent of the query language that is used. You can also define native SQL queries in metadata, or migrate existing queries to Hibernate by placing them in mapping files."
+msgstr "请注意实际的程序代码与所用的查询语言无关，你也可在元数据中定义原生 SQL（native SQL）查询，或将原有的其他的查询语句放在配置文件中，这样就可以让 Hibernate 统一管理，达到迁移的目的。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Also note that a query declaration inside a <literal><hibernate-"
-"mapping></literal> element requires a global unique name for the query, "
-"while a query declaration inside a <literal><class></literal> element "
-"is made unique automatically by prepending the fully qualified name of the "
-"class. For example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
-msgstr ""
-"也请注意在 <literal><hibernate-mapping></literal> 元素中声明的查询必须"
-"有一个全局唯一的名字,而在 <literal><class></literal> 元素中声明的查询自"
-"动具有全局名,是通过类的全名加以限定的。比如 <literal>eg.Cat."
-"ByNameAndMaximumWeight</literal>。 "
+msgid "Also note that a query declaration inside a <literal><hibernate-mapping></literal> element requires a global unique name for the query, while a query declaration inside a <literal><class></literal> element is made unique automatically by prepending the fully qualified name of the class. For example <literal>eg.Cat.ByNameAndMaximumWeight</literal>."
+msgstr "也请注意在 <literal><hibernate-mapping></literal> 元素中声明的查询必须有一个全局唯一的名字,而在 <literal><class></literal> 元素中声明的查询自动具有全局名,是通过类的全名加以限定的。比如 <literal>eg.Cat.ByNameAndMaximumWeight</literal>。 "
#. Tag: title
#, no-c-format
@@ -594,43 +287,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"A collection <emphasis>filter</emphasis> is a special type of query that can "
-"be applied to a persistent collection or array. The query string can refer "
-"to <literal>this</literal>, meaning the current collection element."
-msgstr ""
-"集合<emphasis>过滤器（filter）</emphasis>是一种用于一个持久化集合或者数组的特"
-"殊的查询。查询字符串中可以使用 <literal>\"this\"</literal> 来引用集合中的当前"
-"元素。 "
+msgid "A collection <emphasis>filter</emphasis> is a special type of query that can be applied to a persistent collection or array. The query string can refer to <literal>this</literal>, meaning the current collection element."
+msgstr "集合<emphasis>过滤器（filter）</emphasis>是一种用于一个持久化集合或者数组的特殊的查询。查询字符串中可以使用 <literal>\"this\"</literal> 来引用集合中的当前元素。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The returned collection is considered a bag that is a copy of the given "
-"collection. The original collection is not modified. This is contrary to the "
-"implication of the name \"filter\", but consistent with expected behavior."
-msgstr ""
-"返回的集合可以被认为是一个包（bag，无顺序可重复的集合（collection）），它是所"
-"给集合的副本。 原来的集合不会被改动（这与“过滤器（filter）”的隐含的含义不符，"
-"不过与我们期待的行为一致）。 "
+msgid "The returned collection is considered a bag that is a copy of the given collection. The original collection is not modified. This is contrary to the implication of the name \"filter\", but consistent with expected behavior."
+msgstr "返回的集合可以被认为是一个包（bag，无顺序可重复的集合（collection）），它是所给集合的副本。 原来的集合不会被改动（这与“过滤器（filter）”的隐含的含义不符，不过与我们期待的行为一致）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Observe that filters do not require a <literal>from</literal> clause, "
-"although they can have one if required. Filters are not limited to returning "
-"the collection elements themselves."
-msgstr ""
-"请注意过滤器（filter）并不需要 <literal>from</literal> 子句（当然需要的话它们"
-"也可以加上）。过滤器（filter）不限定于只能返回集合元素本身。 "
+msgid "Observe that filters do not require a <literal>from</literal> clause, although they can have one if required. Filters are not limited to returning the collection elements themselves."
+msgstr "请注意过滤器（filter）并不需要 <literal>from</literal> 子句（当然需要的话它们也可以加上）。过滤器（filter）不限定于只能返回集合元素本身。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Even an empty filter query is useful, e.g. to load a subset of elements in a "
-"large collection:"
-msgstr ""
-"即使无条件的过滤器（filter）也是有意义的。例如，用于加载一个大集合的子集： "
+msgid "Even an empty filter query is useful, e.g. to load a subset of elements in a large collection:"
+msgstr "即使无条件的过滤器（filter）也是有意义的。例如，用于加载一个大集合的子集： "
#. Tag: title
#, no-c-format
@@ -639,25 +312,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"HQL is extremely powerful, but some developers prefer to build queries "
-"dynamically using an object-oriented API, rather than building query "
-"strings. Hibernate provides an intuitive <literal>Criteria</literal> query "
-"API for these cases:"
-msgstr ""
-"HQL 极为强大，但是有些人希望能够动态的使用一种面向对象 API 创建查询，而非在他"
-"们的 Java 代码中嵌入字符串。对于那部分人来说，Hibernate 提供了直观的 "
-"<literal>Criteria</literal> 查询 API。 "
+msgid "HQL is extremely powerful, but some developers prefer to build queries dynamically using an object-oriented API, rather than building query strings. Hibernate provides an intuitive <literal>Criteria</literal> query API for these cases:"
+msgstr "HQL 极为强大，但是有些人希望能够动态的使用一种面向对象 API 创建查询，而非在他们的 Java 代码中嵌入字符串。对于那部分人来说，Hibernate 提供了直观的 <literal>Criteria</literal> 查询 API。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>Criteria</literal> and the associated <literal>Example</"
-"literal> API are discussed in more detail in <xref linkend=\"querycriteria"
-"\" />."
-msgstr ""
-"<literal>Criteria</literal> 以及相关的<literal>样例（Example）</literal>API "
-"将会在 <xref linkend=\"querycriteria\"/> 中详细讨论。"
+#, no-c-format
+msgid "The <literal>Criteria</literal> and the associated <literal>Example</literal> API are discussed in more detail in <xref linkend=\"querycriteria\" />."
+msgstr "<literal>Criteria</literal> 以及相关的<literal>样例（Example）</literal>API 将会在 <xref linkend=\"querycriteria\"/> 中详细讨论。 "
#. Tag: title
#, no-c-format
@@ -666,28 +327,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"You can express a query in SQL, using <literal>createSQLQuery()</literal> "
-"and let Hibernate manage the mapping from result sets to objects. You can at "
-"any time call <literal>session.connection()</literal> and use the JDBC "
-"<literal>Connection</literal> directly. If you choose to use the Hibernate "
-"API, you must enclose SQL aliases in braces:"
-msgstr ""
-"你可以使用 <literal>createSQLQuery()</literal> 方法，用 SQL 来描述查询，并由 "
-"Hibernate 将结果集转换成对象。请注意，你可以在任何时候调用 <literal>session."
-"connection()</literal> 来获得并使用 JDBC <literal>Connection</literal> 对"
-"象。 如果你选择使用 Hibernate 的 API，你必须把 SQL 别名用大括号包围起来： "
+msgid "You can express a query in SQL, using <literal>createSQLQuery()</literal> and let Hibernate manage the mapping from result sets to objects. You can at any time call <literal>session.connection()</literal> and use the JDBC <literal>Connection</literal> directly. If you choose to use the Hibernate API, you must enclose SQL aliases in braces:"
+msgstr "你可以使用 <literal>createSQLQuery()</literal> 方法，用 SQL 来描述查询，并由 Hibernate 将结果集转换成对象。请注意，你可以在任何时候调用 <literal>session.connection()</literal> 来获得并使用 JDBC <literal>Connection</literal> 对象。 如果你选择使用 Hibernate 的 API，你必须把 SQL 别名用大括号包围起来： "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"SQL queries can contain named and positional parameters, just like Hibernate "
-"queries. More information about native SQL queries in Hibernate can be found "
-"in <xref linkend=\"querysql\" />."
-msgstr ""
-"和 Hibernate 查询一样，SQL 查询也可以包含命名参数和占位参数。可以在 <xref "
-"linkend=\"querysql\"/> 找到更多关于 Hibernate 中原生 SQL（native SQL）的信"
-"息。"
+#, no-c-format
+msgid "SQL queries can contain named and positional parameters, just like Hibernate queries. More information about native SQL queries in Hibernate can be found in <xref linkend=\"querysql\" />."
+msgstr "和 Hibernate 查询一样，SQL 查询也可以包含命名参数和占位参数。可以在 <xref linkend=\"querysql\"/> 找到更多关于 Hibernate 中原生 SQL（native SQL）的信息。 "
#. Tag: title
#, no-c-format
@@ -696,61 +342,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<emphasis>Transactional persistent instances</emphasis> (i.e. objects "
-"loaded, saved, created or queried by the <literal>Session</literal>) can be "
-"manipulated by the application, and any changes to persistent state will be "
-"persisted when the <literal>Session</literal> is <emphasis>flushed</"
-"emphasis>. This is discussed later in this chapter. There is no need to call "
-"a particular method (like <literal>update()</literal>, which has a different "
-"purpose) to make your modifications persistent. The most straightforward way "
-"to update the state of an object is to <literal>load()</literal> it and then "
-"manipulate it directly while the <literal>Session</literal> is open:"
-msgstr ""
-"<emphasis>事务中的持久实例</emphasis>（就是通过 <literal>session</literal> 装"
-"载、保存、创建或者查询出的对象） 被应用程序操作所造成的任何修改都会在 "
-"<literal>Session</literal> 被<emphasis>刷出（flushed）</emphasis>的时候被持久"
-"化（本章后面会详细讨论）。这里不需要调用某个特定的方法（比如 <literal>update"
-"()</literal>，设计它的目的是不同的）将你的修改持久化。所以最直接的更新一个对"
-"象的方法就是在 <literal>Session</literal> 处于打开状态时 <literal>load()</"
-"literal> 它，然后直接修改即可： "
+msgid "<emphasis>Transactional persistent instances</emphasis> (i.e. objects loaded, saved, created or queried by the <literal>Session</literal>) can be manipulated by the application, and any changes to persistent state will be persisted when the <literal>Session</literal> is <emphasis>flushed</emphasis>. This is discussed later in this chapter. There is no need to call a particular method (like <literal>update()</literal>, which has a different purpose) to make your modifications persistent. The most straightforward way to update the state of an object is to <literal>load()</literal> it and then manipulate it directly while the <literal>Session</literal> is open:"
+msgstr "<emphasis>事务中的持久实例</emphasis>（就是通过 <literal>session</literal> 装载、保存、创建或者查询出的对象） 被应用程序操作所造成的任何修改都会在 <literal>Session</literal> 被<emphasis>刷出（flushed）</emphasis>的时候被持久化（本章后面会详细讨论）。这里不需要调用某个特定的方法（比如 <literal>update()</literal>，设计它的目的是不同的）将你的修改持久化。所以最直接的更新一个对象的方法就是在 <literal>Session</literal> 处于打开状态时 <literal>load()</literal> 它，然后直接修改即可： "
#. Tag: para
#, no-c-format
-msgid ""
-"Sometimes this programming model is inefficient, as it requires in the same "
-"session both an SQL <literal>SELECT</literal> to load an object and an SQL "
-"<literal>UPDATE</literal> to persist its updated state. Hibernate offers an "
-"alternate approach by using detached instances."
-msgstr ""
-"有时这种程序模型效率低下，因为它在同一 Session 里需要一条 SQL "
-"<literal>SELECT</literal> 语句（用于加载对象） 以及一条 SQL <literal>UPDATE</"
-"literal> 语句（持久化更新的状态）。为此 Hibernate 提供了另一种途径，使用脱管"
-"（detached）实例。 "
+msgid "Sometimes this programming model is inefficient, as it requires in the same session both an SQL <literal>SELECT</literal> to load an object and an SQL <literal>UPDATE</literal> to persist its updated state. Hibernate offers an alternate approach by using detached instances."
+msgstr "有时这种程序模型效率低下，因为它在同一 Session 里需要一条 SQL <literal>SELECT</literal> 语句（用于加载对象） 以及一条 SQL <literal>UPDATE</literal> 语句（持久化更新的状态）。为此 Hibernate 提供了另一种途径，使用脱管（detached）实例。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate does not offer its own API for direct execution of "
-"<literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate "
-"is a <emphasis>state management</emphasis> service, you do not have to think "
-"in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for "
-"executing SQL statements, you can get a JDBC <literal>Connection</literal> "
-"at any time by calling <literal>session.connection()</literal>. Furthermore, "
-"the notion of mass operations conflicts with object/relational mapping for "
-"online transaction processing-oriented applications. Future versions of "
-"Hibernate can, however, provide special mass operation functions. See <xref "
-"linkend=\"batch\" /> for some possible batch operation tricks."
-msgstr ""
-"请注意 Hibernate 本身不提供直接执行 <literal>UPDATE</literal> 或 "
-"<literal>DELETE</literal> 语句的 API。Hibernate 提供的是 <emphasis>state "
-"management</emphasis> 服务，你不必考虑要使用的 <emphasis>statements</"
-"emphasis>。JDBC 是出色的执行 SQL 语句的 API，任何时候调用 <literal>session."
-"connection()</literal> 你都可以得到一个 <literal>Connection</literal> 对象。 "
-"此外，在联机事务处理（OLTP）程序中，大量操作（mass operations）与对象/关系映"
-"射的观点是相冲突的。Hibernate 的将来版本可能会提供专门的进行大量操作（mass "
-"operation）的功能。参考 <xref linkend=\"batch\"/>，寻找一些可用的批量"
-"（batch）操作技巧。"
+#, no-c-format
+msgid "Hibernate does not offer its own API for direct execution of <literal>UPDATE</literal> or <literal>DELETE</literal> statements. Hibernate is a <emphasis>state management</emphasis> service, you do not have to think in <emphasis>statements</emphasis> to use it. JDBC is a perfect API for executing SQL statements, you can get a JDBC <literal>Connection</literal> at any time by calling <literal>session.connection()</literal>. Furthermore, the notion of mass operations conflicts with object/relational mapping for online transaction processing-oriented applications. Future versions of Hibernate can, however, provide special mass operation functions. See <xref linkend=\"batch\" /> for some possible batch operation tricks."
+msgstr "请注意 Hibernate 本身不提供直接执行 <literal>UPDATE</literal> 或 <literal>DELETE</literal> 语句的 API。Hibernate 提供的是 <emphasis>state management</emphasis> 服务，你不必考虑要使用的 <emphasis>statements</emphasis>。JDBC 是出色的执行 SQL 语句的 API，任何时候调用 <literal>session.connection()</literal> 你都可以得到一个 <literal>Connection</literal> 对象。 此外，在联机事务处理（OLTP）程序中，大量操作（mass operations）与对象/关系映射的观点是相冲突的。Hibernate 的将来版本可能会提供专门的进行大量操作（mass operation）的功能。参考 <xref linkend=\"batch\"/>，寻找一些可用的批量（batch）操作技巧。 "
#. Tag: title
#, no-c-format
@@ -759,100 +362,43 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Many applications need to retrieve an object in one transaction, send it to "
-"the UI layer for manipulation, then save the changes in a new transaction. "
-"Applications that use this kind of approach in a high-concurrency "
-"environment usually use versioned data to ensure isolation for the \"long\" "
-"unit of work."
-msgstr ""
-"很多程序需要在某个事务中获取对象，然后将对象发送到界面层去操作，最后在一个新"
-"的事务保存所做的修改。在高并发访问的环境中使用这种方式，通常使用附带版本信息"
-"的数据来保证这些“长“工作单元之间的隔离。"
+msgid "Many applications need to retrieve an object in one transaction, send it to the UI layer for manipulation, then save the changes in a new transaction. Applications that use this kind of approach in a high-concurrency environment usually use versioned data to ensure isolation for the \"long\" unit of work."
+msgstr "很多程序需要在某个事务中获取对象，然后将对象发送到界面层去操作，最后在一个新的事务保存所做的修改。在高并发访问的环境中使用这种方式，通常使用附带版本信息的数据来保证这些“长“工作单元之间的隔离。"
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate supports this model by providing for reattachment of detached "
-"instances using the <literal>Session.update()</literal> or <literal>Session."
-"merge()</literal> methods:"
-msgstr ""
-"Hibernate 通过提供 <literal>Session.update()</literal> 或 <literal>Session."
-"merge()</literal> 重新关联脱管实例的办法来支持这种模型。"
+msgid "Hibernate supports this model by providing for reattachment of detached instances using the <literal>Session.update()</literal> or <literal>Session.merge()</literal> methods:"
+msgstr "Hibernate 通过提供 <literal>Session.update()</literal> 或 <literal>Session.merge()</literal> 重新关联脱管实例的办法来支持这种模型。"
#. Tag: para
#, no-c-format
-msgid ""
-"If the <literal>Cat</literal> with identifier <literal>catId</literal> had "
-"already been loaded by <literal>secondSession</literal> when the application "
-"tried to reattach it, an exception would have been thrown."
-msgstr ""
-"如果具有 <literal>catId</literal> 持久化标识的 <literal>Cat</literal> 之前已"
-"经被<literal>另一Session（secondSession）</literal>装载了， 应用程序进行重关"
-"联操作（reattach）的时候会抛出一个异常。"
+msgid "If the <literal>Cat</literal> with identifier <literal>catId</literal> had already been loaded by <literal>secondSession</literal> when the application tried to reattach it, an exception would have been thrown."
+msgstr "如果具有 <literal>catId</literal> 持久化标识的 <literal>Cat</literal> 之前已经被<literal>另一Session（secondSession）</literal>装载了， 应用程序进行重关联操作（reattach）的时候会抛出一个异常。"
#. Tag: para
#, no-c-format
-msgid ""
-"Use <literal>update()</literal> if you are certain that the session does not "
-"contain an already persistent instance with the same identifier. Use "
-"<literal>merge()</literal> if you want to merge your modifications at any "
-"time without consideration of the state of the session. In other words, "
-"<literal>update()</literal> is usually the first method you would call in a "
-"fresh session, ensuring that the reattachment of your detached instances is "
-"the first operation that is executed."
-msgstr ""
-"如果你确定当前 session 没有包含与之具有相同持久化标识的持久实例，使用 "
-"<literal>update()</literal>。如果想随时合并你的的改动而不考虑 session 的状"
-"态，使用 <literal>merge()</literal>。换句话说，在一个新 session 中通常第一个"
-"调用的是 <literal>update()</literal> 方法，以便保证重新关联脱管（detached）对"
-"象的操作首先被执行。 "
+msgid "Use <literal>update()</literal> if you are certain that the session does not contain an already persistent instance with the same identifier. Use <literal>merge()</literal> if you want to merge your modifications at any time without consideration of the state of the session. In other words, <literal>update()</literal> is usually the first method you would call in a fresh session, ensuring that the reattachment of your detached instances is the first operation that is executed."
+msgstr "如果你确定当前 session 没有包含与之具有相同持久化标识的持久实例，使用 <literal>update()</literal>。如果想随时合并你的的改动而不考虑 session 的状态，使用 <literal>merge()</literal>。换句话说，在一个新 session 中通常第一个调用的是 <literal>update()</literal> 方法，以便保证重新关联脱管（detached）对象的操作首先被执行。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The application should individually <literal>update()</literal> detached "
-"instances that are reachable from the given detached instance "
-"<emphasis>only</emphasis> if it wants their state to be updated. This can be "
-"automated using <emphasis>transitive persistence</emphasis>. See <xref "
-"linkend=\"objectstate-transitive\" /> for more information."
-msgstr ""
-"如果希望相关联的脱管对象（通过引用“可到达”的脱管对象）的数据也要更新到数据库"
-"时（并且也<emphasis>仅仅</emphasis>在这种情况），可以对该相关联的脱管对象单独"
-"调用 <literal>update()</literal> 当然这些可以自动完成，即通过使用<emphasis>传"
-"播性持久化（transitive persistence）</emphasis>，请看 <xref linkend="
-"\"objectstate-transitive\"/>。"
+#, no-c-format
+msgid "The application should individually <literal>update()</literal> detached instances that are reachable from the given detached instance <emphasis>only</emphasis> if it wants their state to be updated. This can be automated using <emphasis>transitive persistence</emphasis>. See <xref linkend=\"objectstate-transitive\" /> for more information."
+msgstr "如果希望相关联的脱管对象（通过引用“可到达”的脱管对象）的数据也要更新到数据库时（并且也<emphasis>仅仅</emphasis>在这种情况），可以对该相关联的脱管对象单独调用 <literal>update()</literal> 当然这些可以自动完成，即通过使用<emphasis>传播性持久化（transitive persistence）</emphasis>，请看 <xref linkend=\"objectstate-transitive\"/>。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>lock()</literal> method also allows an application to "
-"reassociate an object with a new session. However, the detached instance has "
-"to be unmodified."
-msgstr ""
-"<literal>lock()</literal> 方法也允许程序重新关联某个对象到一个新 session 上。"
-"不过，该脱管（detached）的对象必须是没有修改过的。"
+msgid "The <literal>lock()</literal> method also allows an application to reassociate an object with a new session. However, the detached instance has to be unmodified."
+msgstr "<literal>lock()</literal> 方法也允许程序重新关联某个对象到一个新 session 上。不过，该脱管（detached）的对象必须是没有修改过的。"
#. Tag: para
#, no-c-format
-msgid ""
-"Note that <literal>lock()</literal> can be used with various "
-"<literal>LockMode</literal>s. See the API documentation and the chapter on "
-"transaction handling for more information. Reattachment is not the only "
-"usecase for <literal>lock()</literal>."
-msgstr ""
-"请注意，<literal>lock()</literal> 可以搭配多种 <literal>LockMode</literal>，"
-"更多信息请阅读 API 文档以及关于事务处理（transaction handling）的章节。重新关"
-"联不是 <literal>lock()</literal> 的唯一用途。 "
+msgid "Note that <literal>lock()</literal> can be used with various <literal>LockMode</literal>s. See the API documentation and the chapter on transaction handling for more information. Reattachment is not the only usecase for <literal>lock()</literal>."
+msgstr "请注意，<literal>lock()</literal> 可以搭配多种 <literal>LockMode</literal>，更多信息请阅读 API 文档以及关于事务处理（transaction handling）的章节。重新关联不是 <literal>lock()</literal> 的唯一用途。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Other models for long units of work are discussed in <xref linkend="
-"\"transactions-optimistic\" />."
-msgstr ""
-"其他用于长时间工作单元的模型会在 <xref linkend=\"transactions-optimistic\"/> "
-"中讨论。"
+#, no-c-format
+msgid "Other models for long units of work are discussed in <xref linkend=\"transactions-optimistic\" />."
+msgstr "其他用于长时间工作单元的模型会在 <xref linkend=\"transactions-optimistic\"/> 中讨论。 "
#. Tag: title
#, no-c-format
@@ -861,39 +407,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate users have requested a general purpose method that either saves a "
-"transient instance by generating a new identifier or updates/reattaches the "
-"detached instances associated with its current identifier. The "
-"<literal>saveOrUpdate()</literal> method implements this functionality."
-msgstr ""
-"Hibernate 的用户曾要求一个既可自动分配新持久化标识（identifier）保存瞬时"
-"（transient）对象，又可更新/重新关联脱管（detached）实例的通用方法。"
-"<literal>saveOrUpdate()</literal> 方法实现了这个功能。"
+msgid "Hibernate users have requested a general purpose method that either saves a transient instance by generating a new identifier or updates/reattaches the detached instances associated with its current identifier. The <literal>saveOrUpdate()</literal> method implements this functionality."
+msgstr "Hibernate 的用户曾要求一个既可自动分配新持久化标识（identifier）保存瞬时（transient）对象，又可更新/重新关联脱管（detached）实例的通用方法。<literal>saveOrUpdate()</literal> 方法实现了这个功能。"
#. Tag: para
#, no-c-format
-msgid ""
-"The usage and semantics of <literal>saveOrUpdate()</literal> seems to be "
-"confusing for new users. Firstly, so long as you are not trying to use "
-"instances from one session in another new session, you should not need to "
-"use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or "
-"<literal>merge()</literal>. Some whole applications will never use either of "
-"these methods."
-msgstr ""
-"<literal>saveOrUpdate()</literal> 用途和语义可能会使新用户感到迷惑。首先，只"
-"要你没有尝试在某个 session 中使用来自另一 session 的实例，你就应该不需要使"
-"用 <literal>update()</literal>， <literal>saveOrUpdate()</literal>，或 "
-"<literal>merge()</literal>。有些程序从来不用这些方法。"
+msgid "The usage and semantics of <literal>saveOrUpdate()</literal> seems to be confusing for new users. Firstly, so long as you are not trying to use instances from one session in another new session, you should not need to use <literal>update()</literal>, <literal>saveOrUpdate()</literal>, or <literal>merge()</literal>. Some whole applications will never use either of these methods."
+msgstr "<literal>saveOrUpdate()</literal> 用途和语义可能会使新用户感到迷惑。首先，只要你没有尝试在某个 session 中使用来自另一 session 的实例，你就应该不需要使用 <literal>update()</literal>， <literal>saveOrUpdate()</literal>，或 <literal>merge()</literal>。有些程序从来不用这些方法。"
#. Tag: para
#, no-c-format
-msgid ""
-"Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are "
-"used in the following scenario:"
-msgstr ""
-"通常下面的场景会使用 <literal>update()</literal> 或 <literal>saveOrUpdate()</"
-"literal>："
+msgid "Usually <literal>update()</literal> or <literal>saveOrUpdate()</literal> are used in the following scenario:"
+msgstr "通常下面的场景会使用 <literal>update()</literal> 或 <literal>saveOrUpdate()</literal>："
#. Tag: para
#, no-c-format
@@ -917,9 +442,7 @@
#. Tag: para
#, no-c-format
-msgid ""
-"the application persists these modifications by calling <literal>update()</"
-"literal> in a second session"
+msgid "the application persists these modifications by calling <literal>update()</literal> in a second session"
msgstr "程序调用第二个 session 的 <literal>update()</literal> 方法持久这些改动"
#. Tag: para
@@ -934,39 +457,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"if another object associated with the session has the same identifier, throw "
-"an exception"
-msgstr ""
-"如果另一个与本 session 关联的对象拥有相同的持久化标识（identifier），抛出一个"
-"异常"
+msgid "if another object associated with the session has the same identifier, throw an exception"
+msgstr "如果另一个与本 session 关联的对象拥有相同的持久化标识（identifier），抛出一个异常"
#. Tag: para
#, no-c-format
msgid "if the object has no identifier property, <literal>save()</literal> it"
-msgstr ""
-"如果对象没有持久化标识（identifier）属性，对其调用 <literal>save()</literal>"
+msgstr "如果对象没有持久化标识（identifier）属性，对其调用 <literal>save()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"if the object's identifier has the value assigned to a newly instantiated "
-"object, <literal>save()</literal> it"
-msgstr ""
-"如果对象的持久标识（identifier）表明其是一个新实例化的对象，对其调用 "
-"<literal>save()</literal>。"
+msgid "if the object's identifier has the value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "如果对象的持久标识（identifier）表明其是一个新实例化的对象，对其调用 <literal>save()</literal>。"
#. Tag: para
#, no-c-format
-msgid ""
-"if the object is versioned by a <literal><version></literal> or "
-"<literal><timestamp></literal>, and the version property value is the "
-"same value assigned to a newly instantiated object, <literal>save()</"
-"literal> it"
-msgstr ""
-"如果对象是附带版本信息的（通过 <literal><version></literal> 或 "
-"<literal><timestamp></literal>）并且版本属性的值表明其是一个新实例化的"
-"对象，<literal>save()</literal> 它。 "
+msgid "if the object is versioned by a <literal><version></literal> or <literal><timestamp></literal>, and the version property value is the same value assigned to a newly instantiated object, <literal>save()</literal> it"
+msgstr "如果对象是附带版本信息的（通过 <literal><version></literal> 或 <literal><timestamp></literal>）并且版本属性的值表明其是一个新实例化的对象，<literal>save()</literal> 它。 "
#. Tag: para
#, no-c-format
@@ -980,21 +487,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"if there is a persistent instance with the same identifier currently "
-"associated with the session, copy the state of the given object onto the "
-"persistent instance"
-msgstr ""
-"如果 session 中存在相同持久化标识（identifier）的实例，用用户给出的对象的状态"
-"覆盖旧有的持久实例"
+msgid "if there is a persistent instance with the same identifier currently associated with the session, copy the state of the given object onto the persistent instance"
+msgstr "如果 session 中存在相同持久化标识（identifier）的实例，用用户给出的对象的状态覆盖旧有的持久实例"
#. Tag: para
#, no-c-format
-msgid ""
-"if there is no persistent instance currently associated with the session, "
-"try to load it from the database, or create a new persistent instance"
-msgstr ""
-"如果 session 没有相应的持久实例，则尝试从数据库中加载，或创建新的持久化实例"
+msgid "if there is no persistent instance currently associated with the session, try to load it from the database, or create a new persistent instance"
+msgstr "如果 session 没有相应的持久实例，则尝试从数据库中加载，或创建新的持久化实例"
#. Tag: para
#, no-c-format
@@ -1003,9 +502,7 @@
#. Tag: para
#, no-c-format
-msgid ""
-"the given instance does not become associated with the session, it remains "
-"detached"
+msgid "the given instance does not become associated with the session, it remains detached"
msgstr "用户给出的这个对象没有被关联到 session 上，它依旧是脱管的"
#. Tag: title
@@ -1015,28 +512,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>Session.delete()</literal> will remove an object's state from the "
-"database. Your application, however, can still hold a reference to a deleted "
-"object. It is best to think of <literal>delete()</literal> as making a "
-"persistent instance, transient."
-msgstr ""
-"使用 <literal>Session.delete()</literal> 会把对象的状态从数据库中移除。当然，"
-"你的应用程序可能仍然持有一个指向已删除对象的引用。所以，最好这样理解："
-"<literal>delete()</literal> 的用途是把一个持久实例变成瞬时（transient）实"
-"例。 "
+msgid "<literal>Session.delete()</literal> will remove an object's state from the database. Your application, however, can still hold a reference to a deleted object. It is best to think of <literal>delete()</literal> as making a persistent instance, transient."
+msgstr "使用 <literal>Session.delete()</literal> 会把对象的状态从数据库中移除。当然，你的应用程序可能仍然持有一个指向已删除对象的引用。所以，最好这样理解：<literal>delete()</literal> 的用途是把一个持久实例变成瞬时（transient）实例。 "
#. Tag: para
#, no-c-format
-msgid ""
-"You can delete objects in any order, without risk of foreign key constraint "
-"violations. It is still possible to violate a <literal>NOT NULL</literal> "
-"constraint on a foreign key column by deleting objects in the wrong order, e."
-"g. if you delete the parent, but forget to delete the children."
-msgstr ""
-"你可以用你喜欢的任何顺序删除对象，不用担心外键约束冲突。当然，如果你搞错了顺"
-"序，还是有可能引发在外键字段定义的 <literal>NOT NULL</literal> 约束冲突。例如"
-"你删除了父对象，但是忘记删除其子对象。"
+msgid "You can delete objects in any order, without risk of foreign key constraint violations. It is still possible to violate a <literal>NOT NULL</literal> constraint on a foreign key column by deleting objects in the wrong order, e.g. if you delete the parent, but forget to delete the children."
+msgstr "你可以用你喜欢的任何顺序删除对象，不用担心外键约束冲突。当然，如果你搞错了顺序，还是有可能引发在外键字段定义的 <literal>NOT NULL</literal> 约束冲突。例如你删除了父对象，但是忘记删除其子对象。"
#. Tag: title
#, no-c-format
@@ -1045,71 +527,38 @@
#. Tag: para
#, no-c-format
-msgid ""
-"It is sometimes useful to be able to take a graph of persistent instances "
-"and make them persistent in a different datastore, without regenerating "
-"identifier values."
-msgstr ""
-"偶尔会用到不重新生成持久化标识（identifier），将持久实例以及其关联的实例持久"
-"到不同的数据库中的操作。 "
+msgid "It is sometimes useful to be able to take a graph of persistent instances and make them persistent in a different datastore, without regenerating identifier values."
+msgstr "偶尔会用到不重新生成持久化标识（identifier），将持久实例以及其关联的实例持久到不同的数据库中的操作。 "
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>ReplicationMode</literal> determines how <literal>replicate()</"
-"literal> will deal with conflicts with existing rows in the database:"
-msgstr ""
-"<literal>ReplicationMode</literal> 决定在和数据库中已存在记录由冲突时，"
-"<literal>replicate()</literal> 如何处理。 "
+msgid "The <literal>ReplicationMode</literal> determines how <literal>replicate()</literal> will deal with conflicts with existing rows in the database:"
+msgstr "<literal>ReplicationMode</literal> 决定在和数据库中已存在记录由冲突时，<literal>replicate()</literal> 如何处理。 "
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>ReplicationMode.IGNORE</literal>: ignores the object when there is "
-"an existing database row with the same identifier"
-msgstr ""
-"<literal>ReplicationMode.IGNORE</literal>：当某个现有数据库记录具有相同标识符"
-"时忽略它"
+msgid "<literal>ReplicationMode.IGNORE</literal>: ignores the object when there is an existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.IGNORE</literal>：当某个现有数据库记录具有相同标识符时忽略它"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>ReplicationMode.OVERWRITE</literal>: overwrites any existing "
-"database row with the same identifier"
-msgstr ""
-"<literal>ReplicationMode.OVERWRITE</literal>：用相同的标识符覆盖现有数据库记"
-"录"
+msgid "<literal>ReplicationMode.OVERWRITE</literal>: overwrites any existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.OVERWRITE</literal>：用相同的标识符覆盖现有数据库记录"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>ReplicationMode.EXCEPTION</literal>: throws an exception if there "
-"is an existing database row with the same identifier"
-msgstr ""
-"<literal>ReplicationMode.EXCEPTION</literal>：当某个现有数据库记录具有相同标"
-"识符时抛出异常"
+msgid "<literal>ReplicationMode.EXCEPTION</literal>: throws an exception if there is an existing database row with the same identifier"
+msgstr "<literal>ReplicationMode.EXCEPTION</literal>：当某个现有数据库记录具有相同标识符时抛出异常"
#. Tag: para
#, no-c-format
-msgid ""
-"<literal>ReplicationMode.LATEST_VERSION</literal>: overwrites the row if its "
-"version number is earlier than the version number of the object, or ignore "
-"the object otherwise"
-msgstr ""
-"<literal>ReplicationMode.LATEST_VERSION</literal>：如果当前的版本较新，则覆"
-"盖，否则忽略"
+msgid "<literal>ReplicationMode.LATEST_VERSION</literal>: overwrites the row if its version number is earlier than the version number of the object, or ignore the object otherwise"
+msgstr "<literal>ReplicationMode.LATEST_VERSION</literal>：如果当前的版本较新，则覆盖，否则忽略"
#. Tag: para
#, no-c-format
-msgid ""
-"Usecases for this feature include reconciling data entered into different "
-"database instances, upgrading system configuration information during "
-"product upgrades, rolling back changes made during non-ACID transactions and "
-"more."
-msgstr ""
-"这个功能的用途包括使录入的数据在不同数据库中一致，产品升级时升级系统配置信"
-"息，回滚 non-ACID 事务中的修改等等。（译注，non-ACID，非 ACID;ACID，Atomic，"
-"Consistent，Isolated and Durable 的缩写）"
+msgid "Usecases for this feature include reconciling data entered into different database instances, upgrading system configuration information during product upgrades, rolling back changes made during non-ACID transactions and more."
+msgstr "这个功能的用途包括使录入的数据在不同数据库中一致，产品升级时升级系统配置信息，回滚 non-ACID 事务中的修改等等。（译注，non-ACID，非 ACID;ACID，Atomic，Consistent，Isolated and Durable 的缩写）"
#. Tag: title
#, no-c-format
@@ -1118,15 +567,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Sometimes the <literal>Session</literal> will execute the SQL statements "
-"needed to synchronize the JDBC connection's state with the state of objects "
-"held in memory. This process, called <emphasis>flush</emphasis>, occurs by "
-"default at the following points:"
-msgstr ""
-"每间隔一段时间，<literal>Session</literal> 会执行一些必需的 SQL 语句来把内存"
-"中的对象的状态同步到 JDBC 连接中。这个过程被称为<emphasis>刷出（flush）</"
-"emphasis>，默认会在下面的时间点执行： "
+msgid "Sometimes the <literal>Session</literal> will execute the SQL statements needed to synchronize the JDBC connection's state with the state of objects held in memory. This process, called <emphasis>flush</emphasis>, occurs by default at the following points:"
+msgstr "每间隔一段时间，<literal>Session</literal> 会执行一些必需的 SQL 语句来把内存中的对象的状态同步到 JDBC 连接中。这个过程被称为<emphasis>刷出（flush）</emphasis>，默认会在下面的时间点执行： "
#. Tag: para
#, no-c-format
@@ -1150,12 +592,8 @@
#. Tag: para
#, no-c-format
-msgid ""
-"all entity insertions in the same order the corresponding objects were saved "
-"using <literal>Session.save()</literal>"
-msgstr ""
-"所有对实体进行插入的语句，其顺序按照对象执行 <literal>Session.save()</"
-"literal> 的时间顺序 "
+msgid "all entity insertions in the same order the corresponding objects were saved using <literal>Session.save()</literal>"
+msgstr "所有对实体进行插入的语句，其顺序按照对象执行 <literal>Session.save()</literal> 的时间顺序 "
#. Tag: para
#, no-c-format
@@ -1179,67 +617,28 @@
#. Tag: para
#, no-c-format
-msgid ""
-"all entity deletions in the same order the corresponding objects were "
-"deleted using <literal>Session.delete()</literal>"
-msgstr ""
-"所有对实体进行删除的语句，其顺序按照对象执行 <literal>Session.delete()</"
-"literal> 的时间顺序 "
+msgid "all entity deletions in the same order the corresponding objects were deleted using <literal>Session.delete()</literal>"
+msgstr "所有对实体进行删除的语句，其顺序按照对象执行 <literal>Session.delete()</literal> 的时间顺序 "
#. Tag: para
#, no-c-format
-msgid ""
-"An exception is that objects using <literal>native</literal> ID generation "
-"are inserted when they are saved."
-msgstr ""
-"有一个例外是，如果对象使用 <literal>native</literal> 方式来生成 ID（持久化标"
-"识）的话，它们一执行 save 就会被插入。"
+msgid "An exception is that objects using <literal>native</literal> ID generation are inserted when they are saved."
+msgstr "有一个例外是，如果对象使用 <literal>native</literal> 方式来生成 ID（持久化标识）的话，它们一执行 save 就会被插入。"
#. Tag: para
#, no-c-format
-msgid ""
-"Except when you explicitly <literal>flush()</literal>, there are absolutely "
-"no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> "
-"executes the JDBC calls, only the <emphasis>order</emphasis> in which they "
-"are executed. However, Hibernate does guarantee that the <literal>Query.list"
-"(..)</literal> will never return stale or incorrect data."
-msgstr ""
-"除非你明确地发出了 <literal>flush()</literal> 指令，关于 Session<emphasis> 何"
-"时</emphasis>会执行这些 JDBC 调用是完全无法保证的，只能保证它们执行的前后顺"
-"序。当然，Hibernate 保证，<literal>Query.list(..)</literal> 绝对不会返回已经"
-"失效的数据，也不会返回错误数据。 "
+msgid "Except when you explicitly <literal>flush()</literal>, there are absolutely no guarantees about <emphasis>when</emphasis> the <literal>Session</literal> executes the JDBC calls, only the <emphasis>order</emphasis> in which they are executed. However, Hibernate does guarantee that the <literal>Query.list(..)</literal> will never return stale or incorrect data."
+msgstr "除非你明确地发出了 <literal>flush()</literal> 指令，关于 Session<emphasis> 何时</emphasis>会执行这些 JDBC 调用是完全无法保证的，只能保证它们执行的前后顺序。当然，Hibernate 保证，<literal>Query.list(..)</literal> 绝对不会返回已经失效的数据，也不会返回错误数据。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"It is possible to change the default behavior so that flush occurs less "
-"frequently. The <literal>FlushMode</literal> class defines three different "
-"modes: only flush at commit time when the Hibernate <literal>Transaction</"
-"literal> API is used, flush automatically using the explained routine, or "
-"never flush unless <literal>flush()</literal> is called explicitly. The last "
-"mode is useful for long running units of work, where a <literal>Session</"
-"literal> is kept open and disconnected for a long time (see <xref linkend="
-"\"transactions-optimistic-longsession\" />)."
-msgstr ""
-"也可以改变默认的设置，来让刷出（flush）操作发生的不那么频繁。"
-"<literal>FlushMode</literal> 类定义了三种不同的方式。仅在提交时刷出（仅当 "
-"Hibernate 的 <literal>Transaction</literal> API 被使用时有效），按照刚才说的"
-"方式刷出，以及除非明确使用 <literal>flush()</literal> 否则从不刷出。 最后一种"
-"模式对于那些需要长时间保持 <literal>Session</literal> 为打开或者断线状态的长"
-"时间运行的工作单元很有用。（参见 <xref linkend=\"transactions-optimistic-"
-"longsession\"/>）。"
+#, no-c-format
+msgid "It is possible to change the default behavior so that flush occurs less frequently. The <literal>FlushMode</literal> class defines three different modes: only flush at commit time when the Hibernate <literal>Transaction</literal> API is used, flush automatically using the explained routine, or never flush unless <literal>flush()</literal> is called explicitly. The last mode is useful for long running units of work, where a <literal>Session</literal> is kept open and disconnected for a long time (see <xref linkend=\"transactions-optimistic-longsession\" />)."
+msgstr "也可以改变默认的设置，来让刷出（flush）操作发生的不那么频繁。<literal>FlushMode</literal> 类定义了三种不同的方式。仅在提交时刷出（仅当 Hibernate 的 <literal>Transaction</literal> API 被使用时有效），按照刚才说的方式刷出，以及除非明确使用 <literal>flush()</literal> 否则从不刷出。 最后一种模式对于那些需要长时间保持 <literal>Session</literal> 为打开或者断线状态的长时间运行的工作单元很有用。（参见 <xref linkend=\"transactions-optimistic-longsession\"/>）。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"During flush, an exception might occur (e.g. if a DML operation violates a "
-"constraint). Since handling exceptions involves some understanding of "
-"Hibernate's transactional behavior, we discuss it in <xref linkend="
-"\"transactions\" />."
-msgstr ""
-"刷出（flush）期间，可能会抛出异常。（例如一个 DML 操作违反了约束） 异常处理涉"
-"及到对 Hibernate 事务性行为的理解，因此我们将在 <xref linkend=\"transactions"
-"\"/> 中讨论。"
+#, no-c-format
+msgid "During flush, an exception might occur (e.g. if a DML operation violates a constraint). Since handling exceptions involves some understanding of Hibernate's transactional behavior, we discuss it in <xref linkend=\"transactions\" />."
+msgstr "刷出（flush）期间，可能会抛出异常（例如一个 DML 操作违反了约束）。异常处理涉及到对 Hibernate 事务性行为的理解，因此我们将在 <xref linkend=\"transactions\"/> 中讨论。"
#. Tag: title
#, no-c-format
@@ -1248,67 +647,23 @@
#. Tag: para
#, no-c-format
-msgid ""
-"It is quite cumbersome to save, delete, or reattach individual objects, "
-"especially if you deal with a graph of associated objects. A common case is "
-"a parent/child relationship. Consider the following example:"
-msgstr ""
-"对每一个对象都要执行保存，删除或重关联操作让人感觉有点麻烦，尤其是在处理许多"
-"彼此关联的对象的时候。一个常见的例子是父子关系。考虑下面的例子："
+msgid "It is quite cumbersome to save, delete, or reattach individual objects, especially if you deal with a graph of associated objects. A common case is a parent/child relationship. Consider the following example:"
+msgstr "对每一个对象都要执行保存，删除或重关联操作让人感觉有点麻烦，尤其是在处理许多彼此关联的对象的时候。一个常见的例子是父子关系。考虑下面的例子："
#. Tag: para
#, no-c-format
-msgid ""
-"If the children in a parent/child relationship would be value typed (e.g. a "
-"collection of addresses or strings), their life cycle would depend on the "
-"parent and no further action would be required for convenient \"cascading\" "
-"of state changes. When the parent is saved, the value-typed child objects "
-"are saved and when the parent is deleted, the children will be deleted, etc. "
-"This works for operations such as the removal of a child from the "
-"collection. Since value-typed objects cannot have shared references, "
-"Hibernate will detect this and delete the child from the database."
-msgstr ""
-"如果一个父子关系中的子对象是值类型（value typed）（例如，地址或字符串的集合）"
-"的，他们的生命周期会依赖于父对象，可以享受方便的级联操作（Cascading），不需要"
-"额外的动作。父对象被保存时，这些值类型（value typed）子对象也将被保存；父对象"
-"被删除时，子对象也将被删除。这对将一个子对象从集合中移除是同样有效："
-"Hibernate 会检测到，并且因为值类型（value typed）的对象不可能被其他对象引用，"
-"所以 Hibernate 会在数据库中删除这个子对象。 "
+msgid "If the children in a parent/child relationship would be value typed (e.g. a collection of addresses or strings), their life cycle would depend on the parent and no further action would be required for convenient \"cascading\" of state changes. When the parent is saved, the value-typed child objects are saved and when the parent is deleted, the children will be deleted, etc. This works for operations such as the removal of a child from the collection. Since value-typed objects cannot have shared references, Hibernate will detect this and delete the child from the database."
+msgstr "如果一个父子关系中的子对象是值类型（value typed）（例如，地址或字符串的集合）的，他们的生命周期会依赖于父对象，可以享受方便的级联操作（Cascading），不需要额外的动作。父对象被保存时，这些值类型（value typed）子对象也将被保存；父对象被删除时，子对象也将被删除。这对将一个子对象从集合中移除是同样有效：Hibernate 会检测到，并且因为值类型（value typed）的对象不可能被其他对象引用，所以 Hibernate 会在数据库中删除这个子对象。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Now consider the same scenario with parent and child objects being entities, "
-"not value-types (e.g. categories and items, or parent and child cats). "
-"Entities have their own life cycle and support shared references. Removing "
-"an entity from the collection does not mean it can be deleted), and there is "
-"by default no cascading of state from one entity to any other associated "
-"entities. Hibernate does not implement <emphasis>persistence by "
-"reachability</emphasis> by default."
-msgstr ""
-"现在考虑同样的场景，不过父子对象都是实体（entities）类型，而非值类型（value "
-"typed）（例如，类别与个体，或母猫和小猫）。实体有自己的生命期，允许共享对其的"
-"引用（因此从集合中移除一个实体，不意味着它可以被删除），并且实体到其他关联实"
-"体之间默认没有级联操作的设置。 Hibernate 默认不实现所谓的<emphasis>可到达即持"
-"久化（persistence by reachability）</emphasis>的策略。 "
+msgid "Now consider the same scenario with parent and child objects being entities, not value-types (e.g. categories and items, or parent and child cats). Entities have their own life cycle and support shared references. Removing an entity from the collection does not mean it can be deleted), and there is by default no cascading of state from one entity to any other associated entities. Hibernate does not implement <emphasis>persistence by reachability</emphasis> by default."
+msgstr "现在考虑同样的场景，不过父子对象都是实体（entities）类型，而非值类型（value typed）（例如，类别与个体，或母猫和小猫）。实体有自己的生命期，允许共享对其的引用（因此从集合中移除一个实体，不意味着它可以被删除），并且实体到其他关联实体之间默认没有级联操作的设置。 Hibernate 默认不实现所谓的<emphasis>可到达即持久化（persistence by reachability）</emphasis>的策略。 "
#. Tag: para
#, no-c-format
-msgid ""
-"For each basic operation of the Hibernate session - including "
-"<literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), "
-"evict(), replicate()</literal> - there is a corresponding cascade style. "
-"Respectively, the cascade styles are named <literal>create, merge, save-"
-"update, delete, lock, refresh, evict, replicate</literal>. If you want an "
-"operation to be cascaded along an association, you must indicate that in the "
-"mapping document. For example:"
-msgstr ""
-"每个 Hibernate session 的基本操作 — 包括 <literal>persist(), merge(), "
-"saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> "
-"— 都有对应的级联风格（cascade style）。这些级联风格（cascade style）风格分别"
-"命名为 <literal>create, merge, save-update, delete, lock, refresh, evict, "
-"replicate</literal>。如果你希望一个操作被顺着关联关系级联传播，你必须在映射文"
-"件中指出这一点。例如："
+msgid "For each basic operation of the Hibernate session - including <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> - there is a corresponding cascade style. Respectively, the cascade styles are named <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>. If you want an operation to be cascaded along an association, you must indicate that in the mapping document. For example:"
+msgstr "每个 Hibernate session 的基本操作 — 包括 <literal>persist(), merge(), saveOrUpdate(), delete(), lock(), refresh(), evict(), replicate()</literal> — 都有对应的级联风格（cascade style）。这些级联风格（cascade style）风格分别命名为 <literal>create, merge, save-update, delete, lock, refresh, evict, replicate</literal>。如果你希望一个操作被顺着关联关系级联传播，你必须在映射文件中指出这一点。例如："
#. Tag: para
#, no-c-format
@@ -1317,27 +672,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"You can even use <literal>cascade=\"all\"</literal> to specify that "
-"<emphasis>all</emphasis> operations should be cascaded along the "
-"association. The default <literal>cascade=\"none\"</literal> specifies that "
-"no operations are to be cascaded."
-msgstr ""
-"你可以使用 <literal>cascade=\"all\"</literal> 来指定<emphasis>全部</emphasis>"
-"操作都顺着关联关系级联（cascaded）。默认值是 <literal>cascade=\"none\"</"
-"literal>，即任何操作都不会被级联（cascaded）。 "
+msgid "You can even use <literal>cascade=\"all\"</literal> to specify that <emphasis>all</emphasis> operations should be cascaded along the association. The default <literal>cascade=\"none\"</literal> specifies that no operations are to be cascaded."
+msgstr "你可以使用 <literal>cascade=\"all\"</literal> 来指定<emphasis>全部</emphasis>操作都顺着关联关系级联（cascaded）。默认值是 <literal>cascade=\"none\"</literal>，即任何操作都不会被级联（cascaded）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"A special cascade style, <literal>delete-orphan</literal>, applies only to "
-"one-to-many associations, and indicates that the <literal>delete()</literal> "
-"operation should be applied to any child object that is removed from the "
-"association."
-msgstr ""
-"注意有一个特殊的级联风格（cascade style） <literal>delete-orphan</literal>，"
-"只应用于 one-to-many 关联，表明 <literal>delete()</literal> 操作应该被应用于"
-"所有从关联中删除的对象。"
+msgid "A special cascade style, <literal>delete-orphan</literal>, applies only to one-to-many associations, and indicates that the <literal>delete()</literal> operation should be applied to any child object that is removed from the association."
+msgstr "注意有一个特殊的级联风格（cascade style） <literal>delete-orphan</literal>，只应用于 one-to-many 关联，表明 <literal>delete()</literal> 操作应该被应用于所有从关联中删除的对象。"
#. Tag: para
#, no-c-format
@@ -1346,144 +687,63 @@
#. Tag: para
#, no-c-format
-msgid ""
-"It does not usually make sense to enable cascade on a <literal><many-to-"
-"one></literal> or <literal><many-to-many></literal> association. "
-"Cascade is often useful for <literal><one-to-one></literal> and "
-"<literal><one-to-many></literal> associations."
-msgstr ""
-"通常在 <literal><many-to-one></literal> 或 <literal><many-to-"
-"many></literal> 关系中应用级联（cascade）没什么意义。级联（cascade）通常"
-"在 <literal><one-to-one></literal> 和 <literal><one-to-many></"
-"literal> 关系中比较有用。 "
+msgid "It does not usually make sense to enable cascade on a <literal><many-to-one></literal> or <literal><many-to-many></literal> association. Cascade is often useful for <literal><one-to-one></literal> and <literal><one-to-many></literal> associations."
+msgstr "通常在 <literal><many-to-one></literal> 或 <literal><many-to-many></literal> 关系中应用级联（cascade）没什么意义。级联（cascade）通常在 <literal><one-to-one></literal> 和 <literal><one-to-many></literal> 关系中比较有用。 "
#. Tag: para
#, no-c-format
-msgid ""
-"If the child object's lifespan is bounded by the lifespan of the parent "
-"object, make it a <emphasis>life cycle object</emphasis> by specifying "
-"<literal>cascade=\"all,delete-orphan\"</literal>."
-msgstr ""
-"如果子对象的寿命限定在父亲对象的寿命之内，可通过指定 <literal>cascade=\"all,"
-"delete-orphan\"</literal> 将其变为<emphasis>自动生命周期管理的对象"
-"（lifecycle object）</emphasis>。 "
+msgid "If the child object's lifespan is bounded by the lifespan of the parent object, make it a <emphasis>life cycle object</emphasis> by specifying <literal>cascade=\"all,delete-orphan\"</literal>."
+msgstr "如果子对象的寿命限定在父亲对象的寿命之内，可通过指定 <literal>cascade=\"all,delete-orphan\"</literal> 将其变为<emphasis>自动生命周期管理的对象（lifecycle object）</emphasis>。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Otherwise, you might not need cascade at all. But if you think that you will "
-"often be working with the parent and children together in the same "
-"transaction, and you want to save yourself some typing, consider using "
-"<literal>cascade=\"persist,merge,save-update\"</literal>."
-msgstr ""
-"其他情况，你可根本不需要级联（cascade）。但是如果你认为你会经常在某个事务中同"
-"时用到父对象与子对象，并且你希望少打点儿字，可以考虑使用 <literal>cascade="
-"\"persist,merge,save-update\"</literal>。"
+msgid "Otherwise, you might not need cascade at all. But if you think that you will often be working with the parent and children together in the same transaction, and you want to save yourself some typing, consider using <literal>cascade=\"persist,merge,save-update\"</literal>."
+msgstr "其他情况，你可根本不需要级联（cascade）。但是如果你认为你会经常在某个事务中同时用到父对象与子对象，并且你希望少打点儿字，可以考虑使用 <literal>cascade=\"persist,merge,save-update\"</literal>。"
#. Tag: para
#, no-c-format
-msgid ""
-"Mapping an association (either a single valued association, or a collection) "
-"with <literal>cascade=\"all\"</literal> marks the association as a "
-"<emphasis>parent/child</emphasis> style relationship where save/update/"
-"delete of the parent results in save/update/delete of the child or children."
-msgstr ""
-"可以使用 <literal>cascade=\"all\"</literal> 将一个关联关系（无论是对值对象的"
-"关联，或者对一个集合的关联）标记为<emphasis>父/子</emphasis>关系的关联。 这样"
-"对父对象进行 save/update/delete 操作就会导致子对象也进行 save/update/delete "
-"操作。"
+msgid "Mapping an association (either a single valued association, or a collection) with <literal>cascade=\"all\"</literal> marks the association as a <emphasis>parent/child</emphasis> style relationship where save/update/delete of the parent results in save/update/delete of the child or children."
+msgstr "可以使用 <literal>cascade=\"all\"</literal> 将一个关联关系（无论是对值对象的关联，或者对一个集合的关联）标记为<emphasis>父/子</emphasis>关系的关联。 这样对父对象进行 save/update/delete 操作就会导致子对象也进行 save/update/delete 操作。"
#. Tag: para
#, no-c-format
-msgid ""
-"Furthermore, a mere reference to a child from a persistent parent will "
-"result in save/update of the child. This metaphor is incomplete, however. A "
-"child which becomes unreferenced by its parent is <emphasis>not</emphasis> "
-"automatically deleted, except in the case of a <literal><one-to-many></"
-"literal> association mapped with <literal>cascade=\"delete-orphan\"</"
-"literal>. The precise semantics of cascading operations for a parent/child "
-"relationship are as follows:"
-msgstr ""
-"此外，一个持久的父对象对子对象的浅引用（mere reference）会导致子对象被同步 "
-"save/update。不过，这个隐喻（metaphor）的说法并不完整。除非关联是 "
-"<literal><one-to-many></literal> 关联并且被标记为 <literal>cascade="
-"\"delete-orphan\"</literal>，否则父对象失去对某个子对象的引用<emphasis>不会</"
-"emphasis>导致该子对象被自动删除。父子关系的级联（cascading）操作准确语义如"
-"下： "
+msgid "Furthermore, a mere reference to a child from a persistent parent will result in save/update of the child. This metaphor is incomplete, however. A child which becomes unreferenced by its parent is <emphasis>not</emphasis> automatically deleted, except in the case of a <literal><one-to-many></literal> association mapped with <literal>cascade=\"delete-orphan\"</literal>. The precise semantics of cascading operations for a parent/child relationship are as follows:"
+msgstr "此外，一个持久的父对象对子对象的浅引用（mere reference）会导致子对象被同步 save/update。不过，这个隐喻（metaphor）的说法并不完整。除非关联是 <literal><one-to-many></literal> 关联并且被标记为 <literal>cascade=\"delete-orphan\"</literal>，否则父对象失去对某个子对象的引用<emphasis>不会</emphasis>导致该子对象被自动删除。父子关系的级联（cascading）操作准确语义如下： "
#. Tag: para
#, no-c-format
-msgid ""
-"If a parent is passed to <literal>persist()</literal>, all children are "
-"passed to <literal>persist()</literal>"
-msgstr ""
-"如果父对象被 <literal>persist()</literal>，那么所有子对象也会被 "
-"<literal>persist()</literal>"
+msgid "If a parent is passed to <literal>persist()</literal>, all children are passed to <literal>persist()</literal>"
+msgstr "如果父对象被 <literal>persist()</literal>，那么所有子对象也会被 <literal>persist()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"If a parent is passed to <literal>merge()</literal>, all children are passed "
-"to <literal>merge()</literal>"
-msgstr ""
-"如果父对象被 <literal>merge()</literal>，那么所有子对象也会被 <literal>merge"
-"()</literal>"
+msgid "If a parent is passed to <literal>merge()</literal>, all children are passed to <literal>merge()</literal>"
+msgstr "如果父对象被 <literal>merge()</literal>，那么所有子对象也会被 <literal>merge()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"If a parent is passed to <literal>save()</literal>, <literal>update()</"
-"literal> or <literal>saveOrUpdate()</literal>, all children are passed to "
-"<literal>saveOrUpdate()</literal>"
-msgstr ""
-"如果父对象被 <literal>save()</literal>，<literal>update()</literal> 或 "
-"<literal>saveOrUpdate()</literal>，那么所有子对象则会被 <literal>saveOrUpdate"
-"()</literal>"
+msgid "If a parent is passed to <literal>save()</literal>, <literal>update()</literal> or <literal>saveOrUpdate()</literal>, all children are passed to <literal>saveOrUpdate()</literal>"
+msgstr "如果父对象被 <literal>save()</literal>，<literal>update()</literal> 或 <literal>saveOrUpdate()</literal>，那么所有子对象则会被 <literal>saveOrUpdate()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"If a transient or detached child becomes referenced by a persistent parent, "
-"it is passed to <literal>saveOrUpdate()</literal>"
-msgstr ""
-"如果某个持久的父对象引用了瞬时（transient）或者脱管（detached）的子对象，那么"
-"子对象将会被 <literal>saveOrUpdate()</literal>"
+msgid "If a transient or detached child becomes referenced by a persistent parent, it is passed to <literal>saveOrUpdate()</literal>"
+msgstr "如果某个持久的父对象引用了瞬时（transient）或者脱管（detached）的子对象，那么子对象将会被 <literal>saveOrUpdate()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"If a parent is deleted, all children are passed to <literal>delete()</"
-"literal>"
+msgid "If a parent is deleted, all children are passed to <literal>delete()</literal>"
msgstr "如果父对象被删除，那么所有子对象也会被 <literal>delete()</literal>"
#. Tag: para
#, no-c-format
-msgid ""
-"If a child is dereferenced by a persistent parent, <emphasis>nothing special "
-"happens</emphasis> - the application should explicitly delete the child if "
-"necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which "
-"case the \"orphaned\" child is deleted."
-msgstr ""
-"除非被标记为 <literal>cascade=\"delete-orphan\"</literal>（删除“孤儿”模式，此"
-"时不被任何一个父对象引用的子对象会被删除），否则子对象失掉父对象对其的引用"
-"时，<emphasis>什么事也不会发生</emphasis>。如果有特殊需要，应用程序可通过显式"
-"调用 delete() 删除子对象。"
+msgid "If a child is dereferenced by a persistent parent, <emphasis>nothing special happens</emphasis> - the application should explicitly delete the child if necessary - unless <literal>cascade=\"delete-orphan\"</literal>, in which case the \"orphaned\" child is deleted."
+msgstr "除非被标记为 <literal>cascade=\"delete-orphan\"</literal>（删除“孤儿”模式，此时不被任何一个父对象引用的子对象会被删除），否则子对象失掉父对象对其的引用时，<emphasis>什么事也不会发生</emphasis>。如果有特殊需要，应用程序可通过显式调用 delete() 删除子对象。"
#. Tag: para
#, no-c-format
-msgid ""
-"Finally, note that cascading of operations can be applied to an object graph "
-"at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All "
-"operations, if enabled, are cascaded to associated entities reachable when "
-"the operation is executed. However, <literal>save-update</literal> and "
-"<literal>delete-orphan</literal> are transitive for all associated entities "
-"reachable during flush of the <literal>Session</literal>."
-msgstr ""
-"最后，注意操作的级联可能是在<emphasis>调用期（call time）</emphasis>或者"
-"<emphasis>写入期（flush time）</emphasis>作用到对象图上的。所有的操作，如果允"
-"许，都在操作被执行的时候级联到可触及的关联实体上。然而，<literal>save-upate</"
-"literal> 和 <literal>delete-orphan</literal> 是在<literal>Session</literal> "
-"flush 的时候才作用到所有可触及的被关联对象上的。 "
+msgid "Finally, note that cascading of operations can be applied to an object graph at <emphasis>call time</emphasis> or at <emphasis>flush time</emphasis>. All operations, if enabled, are cascaded to associated entities reachable when the operation is executed. However, <literal>save-update</literal> and <literal>delete-orphan</literal> are transitive for all associated entities reachable during flush of the <literal>Session</literal>."
+msgstr "最后，注意操作的级联可能是在<emphasis>调用期（call time）</emphasis>或者<emphasis>写入期（flush time）</emphasis>作用到对象图上的。所有的操作，如果允许，都在操作被执行的时候级联到可触及的关联实体上。然而，<literal>save-upate</literal> 和 <literal>delete-orphan</literal> 是在<literal>Session</literal> flush 的时候才作用到所有可触及的被关联对象上的。 "
#. Tag: title
#, no-c-format
@@ -1492,32 +752,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate requires a rich meta-level model of all entity and value types. "
-"This model can be useful to the application itself. For example, the "
-"application might use Hibernate's metadata to implement a \"smart\" deep-"
-"copy algorithm that understands which objects should be copied (eg. mutable "
-"value types) and which objects that should not (e.g. immutable value types "
-"and, possibly, associated entities)."
-msgstr ""
-"Hibernate 中有一个非常丰富的元级别（meta-level）的模型，含有所有的实体和值类"
-"型数据的元数据。 有时这个模型对应用程序本身也会非常有用。比如说，应用程序可能"
-"在实现一种“智能”的深度拷贝算法时，通过使用 Hibernate 的元数据来了解哪些对象应"
-"该被拷贝（比如，可变的值类型数据），那些不应该（不可变的值类型数据，也许还有"
-"某些被关联的实体）。 "
+msgid "Hibernate requires a rich meta-level model of all entity and value types. This model can be useful to the application itself. For example, the application might use Hibernate's metadata to implement a \"smart\" deep-copy algorithm that understands which objects should be copied (eg. mutable value types) and which objects that should not (e.g. immutable value types and, possibly, associated entities)."
+msgstr "Hibernate 中有一个非常丰富的元级别（meta-level）的模型，含有所有的实体和值类型数据的元数据。 有时这个模型对应用程序本身也会非常有用。比如说，应用程序可能在实现一种“智能”的深度拷贝算法时，通过使用 Hibernate 的元数据来了解哪些对象应该被拷贝（比如，可变的值类型数据），那些不应该（不可变的值类型数据，也许还有某些被关联的实体）。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Hibernate exposes metadata via the <literal>ClassMetadata</literal> and "
-"<literal>CollectionMetadata</literal> interfaces and the <literal>Type</"
-"literal> hierarchy. Instances of the metadata interfaces can be obtained "
-"from the <literal>SessionFactory</literal>."
-msgstr ""
-"Hibernate 提供了 <literal>ClassMetadata</literal> 接口，"
-"<literal>CollectionMetadata</literal> 接口和 <literal>Type</literal> 层次体系"
-"来访问元数据。可以通过 <literal>SessionFactory</literal> 获取元数据接口的实"
-"例。 "
+msgid "Hibernate exposes metadata via the <literal>ClassMetadata</literal> and <literal>CollectionMetadata</literal> interfaces and the <literal>Type</literal> hierarchy. Instances of the metadata interfaces can be obtained from the <literal>SessionFactory</literal>."
+msgstr "Hibernate 提供了 <literal>ClassMetadata</literal> 接口，<literal>CollectionMetadata</literal> 接口和 <literal>Type</literal> 层次体系来访问元数据。可以通过 <literal>SessionFactory</literal> 获取元数据接口的实例。 "
#~ msgid ""
#~ "<![CDATA[DomesticCat fritz = new DomesticCat();\n"
@@ -1531,7 +772,6 @@
#~ "fritz.setSex('M');\n"
#~ "fritz.setName(\"Fritz\");\n"
#~ "Long generatedId = (Long) sess.save(fritz);]]>"
-
#~ msgid ""
#~ "<![CDATA[DomesticCat pk = new DomesticCat();\n"
#~ "pk.setColor(Color.TABBY);\n"
@@ -1548,10 +788,8 @@
#~ "pk.setKittens( new HashSet() );\n"
#~ "pk.addKitten(fritz);\n"
#~ "sess.save( pk, new Long(1234) );]]>"
-
#~ msgid "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
#~ msgstr "<![CDATA[Cat fritz = (Cat) sess.load(Cat.class, generatedId);]]>"
-
#~ msgid ""
#~ "<![CDATA[// you need to wrap primitive identifiers\n"
#~ "long id = 1234;\n"
@@ -1562,7 +800,6 @@
#~ "long id = 1234;\n"
#~ "DomesticCat pk = (DomesticCat) sess.load( DomesticCat.class, new Long"
#~ "(id) );]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat cat = new DomesticCat();\n"
#~ "// load pk's state into cat\n"
@@ -1573,7 +810,6 @@
#~ "// load pk's state into cat\n"
#~ "sess.load( cat, new Long(pkId) );\n"
#~ "Set kittens = cat.getKittens();]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id);\n"
#~ "if (cat==null) {\n"
@@ -1588,12 +824,10 @@
#~ " sess.save(cat, id);\n"
#~ "}\n"
#~ "return cat;]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
#~ msgstr ""
#~ "<![CDATA[Cat cat = (Cat) sess.get(Cat.class, id, LockMode.UPGRADE);]]>"
-
#~ msgid ""
#~ "<![CDATA[sess.save(cat);\n"
#~ "sess.flush(); //force the SQL INSERT\n"
@@ -1602,7 +836,6 @@
#~ "<![CDATA[sess.save(cat);\n"
#~ "sess.flush(); //force the SQL INSERT\n"
#~ "sess.refresh(cat); //re-read the state (after the trigger executes)]]>"
-
#~ msgid ""
#~ "<![CDATA[List cats = session.createQuery(\n"
#~ " \"from Cat as cat where cat.birthdate < ?\")\n"
@@ -1655,7 +888,6 @@
#~ " \"select mother from Cat as mother left join fetch mother.kittens"
#~ "\");\n"
#~ "Set uniqueMothers = new HashSet(mothersWithKittens.list());]]>"
-
#~ msgid ""
#~ "<![CDATA[// fetch ids\n"
#~ "Iterator iter = sess.createQuery(\"from eg.Qux q order by q.likeliness\")."
@@ -1684,7 +916,6 @@
#~ " break;\n"
#~ " }\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[Iterator kittensAndMothers = sess.createQuery(\n"
#~ " \"select kitten, mother from Cat kitten join kitten.mother "
@@ -1711,7 +942,6 @@
#~ " Cat mother = (Cat) tuple[1];\n"
#~ " ....\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[Iterator results = sess.createQuery(\n"
#~ " \"select cat.color, min(cat.birthdate), count(cat) from Cat cat "
@@ -1742,7 +972,6 @@
#~ " Integer count = (Integer) row[2];\n"
#~ " .....\n"
#~ "}]]>"
-
#~ msgid ""
#~ "<![CDATA[//named parameter (preferred)\n"
#~ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = :name"
@@ -1755,7 +984,6 @@
#~ "\");\n"
#~ "q.setString(\"name\", \"Fritz\");\n"
#~ "Iterator cats = q.iterate();]]>"
-
#~ msgid ""
#~ "<![CDATA[//positional parameter\n"
#~ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
@@ -1766,7 +994,6 @@
#~ "Query q = sess.createQuery(\"from DomesticCat cat where cat.name = ?\");\n"
#~ "q.setString(0, \"Izi\");\n"
#~ "Iterator cats = q.iterate();]]>"
-
#~ msgid ""
#~ "<![CDATA[//named parameter list\n"
#~ "List names = new ArrayList();\n"
@@ -1785,7 +1012,6 @@
#~ "namesList)\");\n"
#~ "q.setParameterList(\"namesList\", names);\n"
#~ "List cats = q.list();]]>"
-
#~ msgid ""
#~ "<![CDATA[Query q = sess.createQuery(\"from DomesticCat cat\");\n"
#~ "q.setFirstResult(20);\n"
@@ -1796,7 +1022,6 @@
#~ "q.setFirstResult(20);\n"
#~ "q.setMaxResults(10);\n"
#~ "List cats = q.list();]]>"
-
#~ msgid ""
#~ "<![CDATA[Query q = sess.createQuery(\"select cat.name, cat from "
#~ "DomesticCat cat \" +\n"
@@ -1847,7 +1072,6 @@
#~ "\n"
#~ "}\n"
#~ "cats.close()]]>"
-
#~ msgid ""
#~ "<![CDATA[<query name=\"ByNameAndMaximumWeight\"><![CDATA[\n"
#~ " from eg.DomesticCat as cat\n"
@@ -1860,7 +1084,6 @@
#~ " where cat.name = ?\n"
#~ " and cat.weight > ?\n"
#~ "] ]></query>]]>"
-
#~ msgid ""
#~ "<![CDATA[Query q = sess.getNamedQuery(\"ByNameAndMaximumWeight\");\n"
#~ "q.setString(0, name);\n"
@@ -1871,7 +1094,6 @@
#~ "q.setString(0, name);\n"
#~ "q.setInt(1, minWeight);\n"
#~ "List cats = q.list();]]>"
-
#~ msgid ""
#~ "<![CDATA[Collection blackKittens = session.createFilter(\n"
#~ " pk.getKittens(), \n"
@@ -1886,7 +1108,6 @@
#~ " .setParameter( Color.BLACK, Hibernate.custom(ColorUserType.class) )\n"
#~ " .list()\n"
#~ ");]]>"
-
#~ msgid ""
#~ "<![CDATA[Collection blackKittenMates = session.createFilter(\n"
#~ " pk.getKittens(), \n"
@@ -1897,7 +1118,6 @@
#~ " pk.getKittens(), \n"
#~ " \"select this.mate where this.color = eg.Color.BLACK.intValue\")\n"
#~ " .list();]]>"
-
#~ msgid ""
#~ "<![CDATA[Collection tenKittens = session.createFilter(\n"
#~ " mother.getKittens(), \"\")\n"
@@ -1908,7 +1128,6 @@
#~ " mother.getKittens(), \"\")\n"
#~ " .setFirstResult(0).setMaxResults(10)\n"
#~ " .list();]]>"
-
#~ msgid ""
#~ "<![CDATA[Criteria crit = session.createCriteria(Cat.class);\n"
#~ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
@@ -1919,7 +1138,6 @@
#~ "crit.add( Restrictions.eq( \"color\", eg.Color.BLACK ) );\n"
#~ "crit.setMaxResults(10);\n"
#~ "List cats = crit.list();]]>"
-
#~ msgid ""
#~ "<![CDATA[List cats = session.createSQLQuery(\"SELECT {cat.*} FROM CAT "
#~ "{cat} WHERE ROWNUM<10\")\n"
@@ -1930,7 +1148,6 @@
#~ "{cat} WHERE ROWNUM<10\")\n"
#~ " .addEntity(\"cat\", Cat.class)\n"
#~ ".list();]]>"
-
#~ msgid ""
#~ "<![CDATA[List cats = session.createSQLQuery(\n"
#~ " \"SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, \" +\n"
@@ -1947,7 +1164,6 @@
#~ " \"FROM CAT {cat} WHERE ROWNUM<10\")\n"
#~ " .addEntity(\"cat\", Cat.class)\n"
#~ ".list()]]>"
-
#~ msgid ""
#~ "<![CDATA[DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long"
#~ "(69) );\n"
@@ -1960,7 +1176,6 @@
#~ "cat.setName(\"PK\");\n"
#~ "sess.flush(); // changes to cat are automatically detected and "
#~ "persisted]]>"
-
#~ msgid ""
#~ "<![CDATA[// in the first session\n"
#~ "Cat cat = (Cat) firstSession.load(Cat.class, catId);\n"
@@ -1985,7 +1200,6 @@
#~ "// later, in a new session\n"
#~ "secondSession.update(cat); // update cat\n"
#~ "secondSession.update(mate); // update mate]]>"
-
#~ msgid ""
#~ "<![CDATA[//just reassociate:\n"
#~ "sess.lock(fritz, LockMode.NONE);\n"
@@ -2000,7 +1214,6 @@
#~ "sess.lock(izi, LockMode.READ);\n"
#~ "//do a version check, using SELECT ... FOR UPDATE, then reassociate:\n"
#~ "sess.lock(pk, LockMode.UPGRADE);]]>"
-
#~ msgid ""
#~ "<![CDATA[// in the first session\n"
#~ "Cat cat = (Cat) firstSession.load(Cat.class, catID);\n"
@@ -2027,10 +1240,8 @@
#~ "non-null id)\n"
#~ "secondSession.saveOrUpdate(mate); // save the new instance (mate has a "
#~ "null id)]]>"
-
#~ msgid "<![CDATA[sess.delete(cat);]]>"
#~ msgstr "<![CDATA[sess.delete(cat);]]>"
-
#~ msgid ""
#~ "<![CDATA[//retrieve a cat from one database\n"
#~ "Session session1 = factory1.openSession();\n"
@@ -2059,7 +1270,6 @@
#~ "session2.replicate(cat, ReplicationMode.LATEST_VERSION);\n"
#~ "tx2.commit();\n"
#~ "session2.close();]]>"
-
#~ msgid ""
#~ "<![CDATA[sess = sf.openSession();\n"
#~ "Transaction tx = sess.beginTransaction();\n"
@@ -2092,15 +1302,12 @@
#~ "...\n"
#~ "tx.commit(); // flush occurs\n"
#~ "sess.close();]]>"
-
#~ msgid "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
#~ msgstr "<![CDATA[<one-to-one name=\"person\" cascade=\"persist\"/>]]>"
-
#~ msgid ""
#~ "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
#~ msgstr ""
#~ "<![CDATA[<one-to-one name=\"person\" cascade=\"persist,delete,lock\"/>]]>"
-
#~ msgid ""
#~ "<![CDATA[Cat fritz = ......;\n"
#~ "ClassMetadata catMeta = sessionfactory.getClassMetadata(Cat.class);\n"
@@ -2133,3 +1340,4 @@
#~ " namedValues.put( propertyNames[i], propertyValues[i] );\n"
#~ " }\n"
#~ "}]]>"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/toolset_guide.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/toolset_guide.po 2009-12-04 04:13:58 UTC (rev 97440)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/toolset_guide.po 2009-12-04 05:22:06 UTC (rev 97441)
@@ -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-04 15:04+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -20,86 +20,44 @@
msgstr "工具箱指南"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Roundtrip engineering with Hibernate is possible using a set of Eclipse "
-"plugins, commandline tools, and Ant tasks."
-msgstr ""
-"可以通过一系列 Eclipse 插件、命令行工具和 Ant 任务来进行与 Hibernate 关联的转"
-"换。"
+#, no-c-format
+msgid "Roundtrip engineering with Hibernate is possible using a set of Eclipse plugins, commandline tools, and Ant tasks."
+msgstr "可以通过一系列 Eclipse 插件、命令行工具和 Ant 任务来进行与 Hibernate 关联的转换。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Hibernate Tools</emphasis> currently include plugins for the "
-"Eclipse IDE as well as Ant tasks for reverse engineering of existing "
-"databases:"
-msgstr ""
-"除了 Ant 任务外，当前的 <emphasis>Hibernate Tools</emphasis> 也包含了 "
-"Eclipse IDE 的插件，用于与现存数据库的逆向工程。"
+#, no-c-format
+msgid "<emphasis>Hibernate Tools</emphasis> currently include plugins for the Eclipse IDE as well as Ant tasks for reverse engineering of existing databases:"
+msgstr "除了 Ant 任务外，当前的 <emphasis>Hibernate Tools</emphasis> 也包含了 Eclipse IDE 的插件，用于与现存数据库的逆向工程。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Mapping Editor:</emphasis> an editor for Hibernate XML mapping "
-"files that supports auto-completion and syntax highlighting. It also "
-"supports semantic auto-completion for class names and property/field names, "
-"making it more versatile than a normal XML editor."
-msgstr ""
-"<emphasis>Mapping Editor:</emphasis> Hibernate XML 映射文件的编辑器，支持自动"
-"完成和语法高亮。它也支持对类名和属性/字段名的语义自动完成，比通常的 XML 编辑"
-"器方便得多。"
+#, no-c-format
+msgid "<emphasis>Mapping Editor:</emphasis> an editor for Hibernate XML mapping files that supports auto-completion and syntax highlighting. It also supports semantic auto-completion for class names and property/field names, making it more versatile than a normal XML editor."
+msgstr "<emphasis>Mapping Editor:</emphasis> Hibernate XML 映射文件的编辑器，支持自动完成和语法高亮。它也支持对类名和属性/字段名的语义自动完成，比通常的 XML 编辑器方便得多。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Console:</emphasis> the console is a new view in Eclipse. In "
-"addition to a tree overview of your console configurations, you are also "
-"provided with an interactive view of your persistent classes and their "
-"relationships. The console allows you to execute HQL queries against your "
-"database and browse the result directly in Eclipse."
-msgstr ""
-"<emphasis>Console:</emphasis> Console 是 Eclipse 的一个新视图。除了对你的 "
-"console 配置的树状概览，你还可以获得对你持久化类及其关联的交互式视图。"
-"Console 允许你对数据库执行 HQL 查询，并直接在 Eclipse 中浏览结果。"
+#, no-c-format
+msgid "<emphasis>Console:</emphasis> the console is a new view in Eclipse. In addition to a tree overview of your console configurations, you are also provided with an interactive view of your persistent classes and their relationships. The console allows you to execute HQL queries against your database and browse the result directly in Eclipse."
+msgstr "<emphasis>Console:</emphasis> Console 是 Eclipse 的一个新视图。除了对你的 console 配置的树状概览，你还可以获得对你持久化类及其关联的交互式视图。Console 允许你对数据库执行 HQL 查询，并直接在 Eclipse 中浏览结果。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<emphasis>Development Wizards:</emphasis> several wizards are provided with "
-"the Hibernate Eclipse tools. You can use a wizard to quickly generate "
-"Hibernate configuration (cfg.xml) files, or to reverse engineer an existing "
-"database schema into POJO source files and Hibernate mapping files. The "
-"reverse engineering wizard supports customizable templates."
-msgstr ""
-"<emphasis>Development Wizards:</emphasis> 在 Hibernate Eclipse tools 中还提供"
-"了几个向导；你可以用向导快速生成 Hibernate 配置文件（cfg.xml），你甚至还可以"
-"同现存的数据库 schema 中反向工程出 POJO 源代码与 Hibernate 映射文件。反向工程"
-"支持可定制的模版。"
+#, no-c-format
+msgid "<emphasis>Development Wizards:</emphasis> several wizards are provided with the Hibernate Eclipse tools. You can use a wizard to quickly generate Hibernate configuration (cfg.xml) files, or to reverse engineer an existing database schema into POJO source files and Hibernate mapping files. The reverse engineering wizard supports customizable templates."
+msgstr "<emphasis>Development Wizards:</emphasis> 在 Hibernate Eclipse tools 中还提供了几个向导；你可以用向导快速生成 Hibernate 配置文件（cfg.xml），你甚至还可以同现存的数据库 schema 中反向工程出 POJO 源代码与 Hibernate 映射文件。反向工程支持可定制的模版。 "
#. Tag: para
#, no-c-format
msgid "<!-- <emphasis>Ant Tasks:</emphasis> -->"
-msgstr ""
+msgstr "<!-- <emphasis>Ant Tasks:</emphasis> -->"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Please refer to the <emphasis>Hibernate Tools</emphasis> package "
-"documentation for more information."
-msgstr ""
-"要得到更多信息，请查阅 <emphasis>Hibernate Tools</emphasis> 包及其文档。"
+#, no-c-format
+msgid "Please refer to the <emphasis>Hibernate Tools</emphasis> package documentation for more information."
+msgstr "要得到更多信息，请查阅 <emphasis>Hibernate Tools</emphasis> 包及其文档。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"However, the Hibernate main package comes bundled with an integrated tool : "
-"<emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>.It can even "
-"be used from \"inside\" Hibernate."
-msgstr ""
-"同时，Hibernate 主发行包还附带了一个集成的工具（它甚至可以在 Hibernate“内"
-"部”快速运行）<emphasis>SchemaExport</emphasis> ，也就是 <literal>hbm2ddl</"
-"literal>。"
+#, no-c-format
+msgid "However, the Hibernate main package comes bundled with an integrated tool : <emphasis>SchemaExport</emphasis> aka <literal>hbm2ddl</literal>.It can even be used from \"inside\" Hibernate."
+msgstr "同时，Hibernate 主发行包还附带了一个集成的工具（它甚至可以在 Hibernate“内部”快速运行）<emphasis>SchemaExport</emphasis> ，也就是 <literal>hbm2ddl</literal>。 "
#. Tag: title
#, no-c-format
@@ -107,34 +65,19 @@
msgstr "Schema 自动生成（Automatic schema generation）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"DDL can be generated from your mapping files by a Hibernate utility. The "
-"generated schema includes referential integrity constraints, primary and "
-"foreign keys, for entity and collection tables. Tables and sequences are "
-"also created for mapped identifier generators."
-msgstr ""
-"可以从你的映射文件使用一个 Hibernate 工具生成 DDL。生成的 schema 包含有对实体"
-"和集合类表的完整性引用约束（主键和外键）。涉及到的标示符生成器所需的表和 "
-"sequence 也会同时生成。"
+#, no-c-format
+msgid "DDL can be generated from your mapping files by a Hibernate utility. The generated schema includes referential integrity constraints, primary and foreign keys, for entity and collection tables. Tables and sequences are also created for mapped identifier generators."
+msgstr "可以从你的映射文件使用一个 Hibernate 工具生成 DDL。生成的 schema 包含有对实体和集合类表的完整性引用约束（主键和外键）。涉及到的标示符生成器所需的表和 sequence 也会同时生成。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via "
-"the <literal>hibernate.dialect</literal> property when using this tool, as "
-"DDL is highly vendor-specific."
-msgstr ""
-"在使用这个工具的时候，你<emphasis>必须</emphasis> 通过 <literal>hibernate."
-"dialet</literal> 属性指定一个 SQL<literal> 方言（Dialet）</literal>，因为 "
-"DDL 是与供应商高度相关的。"
+#, no-c-format
+msgid "You <emphasis>must</emphasis> specify a SQL <literal>Dialect</literal> via the <literal>hibernate.dialect</literal> property when using this tool, as DDL is highly vendor-specific."
+msgstr "在使用这个工具的时候，你<emphasis>必须</emphasis> 通过 <literal>hibernate.dialet</literal> 属性指定一个 SQL<literal> 方言（Dialet）</literal>，因为 DDL 是与供应商高度相关的。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"First, you must customize your mapping files to improve the generated "
-"schema. The next section covers schema customization."
-msgstr "首先，要定制你的映射文件，来改善生成的 schema。"
+#, no-c-format
+msgid "First, you must customize your mapping files to improve the generated schema. The next section covers schema customization."
+msgstr "首先，要定制你的映射文件，来改善生成的 schema。下章将涵盖 schema 定制。"
#. Tag: title
#, no-c-format
@@ -142,101 +85,54 @@
msgstr "对 schema 定制化（Customizing the schema）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Many Hibernate mapping elements define optional attributes named "
-"<literal>length</literal>, <literal>precision</literal> and <literal>scale</"
-"literal>. You can set the length, precision and scale of a column with this "
-"attribute."
-msgstr ""
-"很多 Hibernate 映射元素定义了可选的 <literal>length</literal>、"
-"<literal>precision</literal> 或者 <literal>scale</literal> 属性。你可以通过这"
-"个属性设置字段的长度、精度、小数点位数。"
+#, no-c-format
+msgid "Many Hibernate mapping elements define optional attributes named <literal>length</literal>, <literal>precision</literal> and <literal>scale</literal>. You can set the length, precision and scale of a column with this attribute."
+msgstr "很多 Hibernate 映射元素定义了可选的 <literal>length</literal>、<literal>precision</literal> 或者 <literal>scale</literal> 属性。你可以通过这个属性设置字段的长度、精度、小数点位数。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"Some tags also accept a <literal>not-null</literal> attribute for generating "
-"a <literal>NOT NULL</literal> constraint on table columns, and a "
-"<literal>unique</literal> attribute for generating <literal>UNIQUE</literal> "
-"constraint on table columns."
-msgstr ""
-"有些 tag 还接受 <literal>not-null</literal> 属性（用来在表字段上生成 "
-"<literal>NOT NULL</literal> 约束）和 <literal>unique</literal> 属性（用来在表"
-"字段上生成 <literal>UNIQUE</literal> 约束）。"
+#, no-c-format
+msgid "Some tags also accept a <literal>not-null</literal> attribute for generating a <literal>NOT NULL</literal> constraint on table columns, and a <literal>unique</literal> attribute for generating <literal>UNIQUE</literal> constraint on table columns."
+msgstr "有些 tag 还接受 <literal>not-null</literal> 属性（用来在表字段上生成 <literal>NOT NULL</literal> 约束）和 <literal>unique</literal> 属性（用来在表字段上生成 <literal>UNIQUE</literal> 约束）。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>unique-key</literal> attribute can be used to group columns in a "
-"single, unique key constraint. Currently, the specified value of the "
-"<literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to "
-"name the constraint in the generated DDL. It is only used to group the "
-"columns in the mapping file."
-msgstr ""
-"<literal>unique-key</literal> 属性可以对成组的字段指定一个唯一键约束（unique "
-"key constraint）。目前，<literal>unique-key</literal> 属性指定的值在生成 DDL "
-"时<emphasis>并不会</emphasis>被当作这个约束的名字，它们只是在用来在映射文件内"
-"部用作区分的。"
+#, no-c-format
+msgid "A <literal>unique-key</literal> attribute can be used to group columns in a single, unique key constraint. Currently, the specified value of the <literal>unique-key</literal> attribute is <emphasis>not</emphasis> used to name the constraint in the generated DDL. It is only used to group the columns in the mapping file."
+msgstr "<literal>unique-key</literal> 属性可以对成组的字段指定一个唯一键约束（unique key constraint）。目前，<literal>unique-key</literal> 属性指定的值在生成 DDL 时<emphasis>并不会</emphasis>被当作这个约束的名字，它们只是在用来在映射文件内部用作区分的。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"An <literal>index</literal> attribute specifies the name of an index that "
-"will be created using the mapped column or columns. Multiple columns can be "
-"grouped into the same index by simply specifying the same index name."
-msgstr ""
-"<literal>index</literal> 属性会用对应的字段（一个或多个）生成一个 index，它指"
-"出了这个 index 的名字。如果多个字段对应的 index 名字相同，就会生成包含这些字"
-"段的 index。"
+#, no-c-format
+msgid "An <literal>index</literal> attribute specifies the name of an index that will be created using the mapped column or columns. Multiple columns can be grouped into the same index by simply specifying the same index name."
+msgstr "<literal>index</literal> 属性会用对应的字段（一个或多个）生成一个 index，它指出了这个 index 的名字。如果多个字段对应的 index 名字相同，就会生成包含这些字段的 index。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>foreign-key</literal> attribute can be used to override the name "
-"of any generated foreign key constraint."
-msgstr ""
-"<literal>foreign-key</literal> 属性可以用来覆盖任何生成的外键约束的名字。"
+#, no-c-format
+msgid "A <literal>foreign-key</literal> attribute can be used to override the name of any generated foreign key constraint."
+msgstr "<literal>foreign-key</literal> 属性可以用来覆盖任何生成的外键约束的名字。 "
#. Tag: para
#, no-c-format
-msgid ""
-"Many mapping elements also accept a child <literal><column></literal> "
-"element. This is particularly useful for mapping multi-column types:"
-msgstr ""
-"很多映射元素还接受 <literal><column></literal> 子元素。这在定义跨越多字"
-"段的类型时特别有用。"
+msgid "Many mapping elements also accept a child <literal><column></literal> element. This is particularly useful for mapping multi-column types:"
+msgstr "很多映射元素还接受 <literal><column></literal> 子元素。这在定义跨越多字段的类型时特别有用。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>default</literal> attribute allows you to specify a default "
-"value for a column.You should assign the same value to the mapped property "
-"before saving a new instance of the mapped class."
-msgstr ""
-"<literal>default</literal> 属性为字段指定一个默认值 （在保存被映射的类的新实"
-"例之前，你应该将同样的值赋于对应的属性）。"
+#, no-c-format
+msgid "The <literal>default</literal> attribute allows you to specify a default value for a column.You should assign the same value to the mapped property before saving a new instance of the mapped class."
+msgstr "<literal>default</literal> 属性为字段指定一个默认值（在保存被映射的类的新实例之前，你应该将同样的值赋于对应的属性）。"
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>sql-type</literal> attribute allows the user to override the "
-"default mapping of a Hibernate type to SQL datatype."
-msgstr ""
-"<literal>sql-type</literal> 属性允许用户覆盖默认的 Hibernate 类型到 SQL 数据"
-"类型的映射。"
+msgid "The <literal>sql-type</literal> attribute allows the user to override the default mapping of a Hibernate type to SQL datatype."
+msgstr "<literal>sql-type</literal> 属性允许用户覆盖默认的 Hibernate 类型到 SQL 数据类型的映射。"
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>check</literal> attribute allows you to specify a check "
-"constraint."
+msgid "The <literal>check</literal> attribute allows you to specify a check constraint."
msgstr "<literal>check</literal> 属性允许用户指定一个约束检查。"
#. Tag: para
#, no-c-format
msgid "The following table summarizes these optional attributes."
-msgstr ""
+msgstr "下表总结了这些可选属性："
#. Tag: title
#, no-c-format
@@ -259,9 +155,9 @@
msgstr "解释（Interpretation）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>length</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>length</literal>"
#. Tag: entry
#, no-c-format
@@ -274,9 +170,9 @@
msgstr "字段长度"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>precision</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>precision</literal>"
#. Tag: entry
#, no-c-format
@@ -284,9 +180,9 @@
msgstr "精度（decimal precision）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>scale</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>scale</literal>"
#. Tag: entry
#, no-c-format
@@ -294,24 +190,24 @@
msgstr "小数点位数（decimal scale）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>not-null</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>not-null</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>true|false</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>true|false</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "specifies that the column should be non-nullable"
-msgstr "指明字段是否应该是非空的"
+msgstr "指明字段是否应该是非空的 "
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>unique</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>unique</literal>"
#. Tag: entry
#, no-c-format
@@ -319,14 +215,14 @@
msgstr "指明是否该字段具有惟一约束"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>index</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>index</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>index_name</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>index_name</literal>"
#. Tag: entry
#, no-c-format
@@ -334,14 +230,14 @@
msgstr "指明一个（多字段）的索引（index）的名字"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>unique-key</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>unique-key</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>unique_key_name</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>unique_key_name</literal>"
#. Tag: entry
#, no-c-format
@@ -349,51 +245,39 @@
msgstr "指明多字段惟一约束的名字（参见上面的说明）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>foreign-key</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>foreign-key</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>foreign_key_name</literal>"
-msgstr "foreign_key_name"
+msgstr "<literal>foreign_key_name</literal>"
#. Tag: entry
#, no-c-format
-msgid ""
-"specifies the name of the foreign key constraint generated for an "
-"association, for a <literal><one-to-one></literal>, <literal><many-"
-"to-one></literal>, <literal><key></literal>, or <literal><many-"
-"to-many></literal> mapping element. Note that <literal>inverse=\"true\"</"
-"literal> sides will not be considered by <literal>SchemaExport</literal>."
-msgstr ""
-"指明一个外键的名字，它是为关联生成的，或者是为 <literal><one-to-one></"
-"literal>, <literal><many-to-one></literal>, <literal><key></"
-"literal>, or <literal><many-to-many></literal> 映射元素。注意 "
-"<literal>inverse=\"true\"</literal> 会被 <literal>SchemaExport</literal> 忽"
-"略。"
+msgid "specifies the name of the foreign key constraint generated for an association, for a <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> mapping element. Note that <literal>inverse=\"true\"</literal> sides will not be considered by <literal>SchemaExport</literal>."
+msgstr "指明一个外键的名字，它是为关联生成的，或者是为 <literal><one-to-one></literal>, <literal><many-to-one></literal>, <literal><key></literal>, or <literal><many-to-many></literal> 映射元素。注意 <literal>inverse=\"true\"</literal> 会被 <literal>SchemaExport</literal> 忽略。"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>sql-type</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>sql-type</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>SQL column type</literal>"
-msgstr "SQL 字段类型"
+msgstr "<literal>SQL column type</literal>"
#. Tag: entry
#, no-c-format
-msgid ""
-"overrides the default column type (attribute of <literal><column></"
-"literal> element only)"
+msgid "overrides the default column type (attribute of <literal><column></literal> element only)"
msgstr "覆盖默认的字段类型（只能用于 <literal><column></literal> 属性）"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>default</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>default</literal>"
#. Tag: entry
#, no-c-format
@@ -406,9 +290,9 @@
msgstr "为字段指定默认值"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>check</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>check</literal>"
#. Tag: entry
#, no-c-format
@@ -417,20 +301,13 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal><comment></literal> element allows you to specify "
-"comments for the generated schema."
-msgstr ""
-"<literal><comment></literal> 元素可以让你在生成的 schema 中加入注释。"
+msgid "The <literal><comment></literal> element allows you to specify comments for the generated schema."
+msgstr "<literal><comment></literal> 元素可以让你在生成的 schema 中加入注释。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"This results in a <literal>comment on table</literal> or <literal>comment on "
-"column</literal> statement in the generated DDL where supported."
-msgstr ""
-"结果是在生成的 DDL 中包含 <literal>comment on table</literal> 或者 "
-"<literal>comment on column</literal> 语句（假若支持的话）。"
+#, no-c-format
+msgid "This results in a <literal>comment on table</literal> or <literal>comment on column</literal> statement in the generated DDL where supported."
+msgstr "结果是在生成的 DDL 中包含 <literal>comment on table</literal> 或者 <literal>comment on column</literal> 语句（假若支持的话）。 "
#. Tag: title
#, no-c-format
@@ -439,30 +316,18 @@
#. Tag: para
#, no-c-format
-msgid ""
-"The <literal>SchemaExport</literal> tool writes a DDL script to standard out "
-"and/or executes the DDL statements."
-msgstr ""
-"<literal>SchemaExport</literal> 工具把 DDL 脚本写到标准输出，同时/或者执行 "
-"DDL 语句。"
+msgid "The <literal>SchemaExport</literal> tool writes a DDL script to standard out and/or executes the DDL statements."
+msgstr "<literal>SchemaExport</literal> 工具把 DDL 脚本写到标准输出，同时/或者执行 DDL 语句。"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The following table displays the <literal>SchemaExport</literal> command "
-"line options"
-msgstr "<literal>SchemaExport</literal> 命令行选项"
+#, no-c-format
+msgid "The following table displays the <literal>SchemaExport</literal> command line options"
+msgstr "下表显示了 <literal>SchemaExport</literal> 命令行选项"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> "
-"<literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options "
-"mapping_files</emphasis>"
-msgstr ""
-"<literal>java -cp </literal><emphasis>hibernate_classpaths</"
-"emphasis><literal>org.hibernate.tool.hbm2ddl.SchemaExport</"
-"literal><emphasis>options mapping_files</emphasis>"
+#, no-c-format
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaExport</literal> <emphasis>options mapping_files</emphasis>"
#. Tag: title
#, no-c-format
@@ -480,19 +345,19 @@
msgstr "描述"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--quiet</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>--quiet</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "do not output the script to stdout"
-msgstr "不要把脚本输出到 stdout"
+msgstr "不要把脚本输出到 stdout "
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--drop</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>--drop</literal>"
#. Tag: entry
#, no-c-format
@@ -500,9 +365,9 @@
msgstr "只进行 drop tables 的步骤"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--create</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>--create</literal>"
#. Tag: entry
#, no-c-format
@@ -510,19 +375,19 @@
msgstr "只创建表"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--text</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>--text</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "do not export to the database"
-msgstr "不执行在数据库中运行的步骤"
+msgstr "不执行在数据库中运行的步骤 "
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--output=my_schema.ddl</literal>"
-msgstr "--output=my_schema.ddl"
+msgstr "<literal>--output=my_schema.ddl</literal>"
#. Tag: entry
#, no-c-format
@@ -530,9 +395,9 @@
msgstr "把输出的 ddl 脚本输出到一个文件"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--naming=eg.MyNamingStrategy</literal>"
-msgstr "--naming=eg.MyNamingStrategy"
+msgstr "<literal>--naming=eg.MyNamingStrategy</literal>"
#. Tag: entry
#, no-c-format
@@ -540,9 +405,9 @@
msgstr "选择 <literal>NamingStrategy</literal>"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--config=hibernate.cfg.xml</literal>"
-msgstr "--config=hibernate.cfg.xml"
+msgstr "<literal>--config=hibernate.cfg.xml</literal>"
#. Tag: entry
#, no-c-format
@@ -550,9 +415,9 @@
msgstr "从 XML 文件读入 Hibernate 配置"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--properties=hibernate.properties</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>--properties=hibernate.properties</literal>"
#. Tag: entry
#, no-c-format
@@ -560,9 +425,9 @@
msgstr "从文件读入数据库属性"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--format</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>--format</literal>"
#. Tag: entry
#, no-c-format
@@ -570,9 +435,9 @@
msgstr "把脚本中的 SQL 语句对齐和美化"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>--delimiter=;</literal>"
-msgstr "选择 <literal>NamingStrategy</literal>"
+msgstr "<literal>--delimiter=;</literal>"
#. Tag: entry
#, no-c-format
@@ -580,9 +445,9 @@
msgstr "为脚本设置行结束符"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "You can even embed <literal>SchemaExport</literal> in your application:"
-msgstr "你甚至可以在你的应用程序中嵌入 <literal>SchemaExport</literal> 工具："
+msgstr "你甚至可以在你的应用程序中嵌入 <literal>SchemaExport</literal> 工具： "
#. Tag: title
#, no-c-format
@@ -590,17 +455,14 @@
msgstr "属性（Properties）"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Database properties can be specified:"
-msgstr "可以通过如下方式指定数据库属性："
+msgstr "可以通过如下方式指定数据库属性： "
#. Tag: para
#, no-c-format
-msgid ""
-"as system properties with <literal>-D</literal><emphasis><property></"
-"emphasis>"
-msgstr ""
-"通过 <literal>-D</literal><emphasis><property></emphasis> 系统参数"
+msgid "as system properties with <literal>-D</literal><emphasis><property></emphasis>"
+msgstr "通过 <literal>-D</literal><emphasis><property></emphasis> 系统参数"
#. Tag: para
#, no-c-format
@@ -610,9 +472,7 @@
#. Tag: para
#, no-c-format
msgid "in a named properties file with <literal>--properties</literal>"
-msgstr ""
-"位于一个其它名字的 properties 文件中,然后用 <literal>--properties</literal> "
-"参数指定"
+msgstr "位于一个其它名字的 properties 文件中,然后用 <literal>--properties</literal> 参数指定"
#. Tag: para
#, no-c-format
@@ -630,9 +490,9 @@
msgstr "属性名"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>hibernate.connection.driver_class</literal>"
-msgstr "hibernate.connection.driver_class"
+msgstr "<literal>hibernate.connection.driver_class</literal>"
#. Tag: entry
#, no-c-format
@@ -640,9 +500,9 @@
msgstr "jdbc driver class"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>hibernate.connection.url</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>hibernate.connection.url</literal>"
#. Tag: entry
#, no-c-format
@@ -650,9 +510,9 @@
msgstr "jdbc url"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>hibernate.connection.username</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>hibernate.connection.username</literal>"
#. Tag: entry
#, no-c-format
@@ -660,9 +520,9 @@
msgstr "database user"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>hibernate.connection.password</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>hibernate.connection.password</literal>"
#. Tag: entry
#, no-c-format
@@ -670,9 +530,9 @@
msgstr "user password"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>hibernate.dialect</literal>"
-msgstr "在 <literal>hibernate.properties</literal> 文件中"
+msgstr "<literal>hibernate.dialect</literal>"
#. Tag: entry
#, no-c-format
@@ -686,8 +546,7 @@
#. Tag: para
#, no-c-format
-msgid ""
-"You can call <literal>SchemaExport</literal> from your Ant build script:"
+msgid "You can call <literal>SchemaExport</literal> from your Ant build script:"
msgstr "你可以在你的 Ant build 脚本中调用 <literal>SchemaExport</literal>："
#. Tag: title
@@ -696,26 +555,14 @@
msgstr "对 schema 的增量更新（Incremental schema updates）"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>SchemaUpdate</literal> tool will update an existing schema with "
-"\"incremental\" changes. The <literal>SchemaUpdate</literal> depends upon "
-"the JDBC metadata API and, as such, will not work with all JDBC drivers."
-msgstr ""
-"<literal>SchemaUpdate</literal> 工具对已存在的 schema 采用\"增量\"方式进行更"
-"新。注意 <literal>SchemaUpdate</literal> 严重依赖于 JDBC metadata API，所以它"
-"并非对所有 JDBC 驱动都有效。"
+#, no-c-format
+msgid "The <literal>SchemaUpdate</literal> tool will update an existing schema with \"incremental\" changes. The <literal>SchemaUpdate</literal> depends upon the JDBC metadata API and, as such, will not work with all JDBC drivers."
+msgstr "<literal>SchemaUpdate</literal> 工具对已存在的 schema 采用\"增量\"方式进行更新。注意 <literal>SchemaUpdate</literal> 严重依赖于 JDBC metadata API，所以它并非对所有 JDBC 驱动都有效。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> "
-"<literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options "
-"mapping_files</emphasis>"
-msgstr ""
-"<literal>java -cp </literal><emphasis>hibernate_classpaths</"
-"emphasis><literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</"
-"literal><emphasis>options mapping_files</emphasis>"
+#, no-c-format
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaUpdate</literal> <emphasis>options mapping_files</emphasis>"
#. Tag: title
#, no-c-format
@@ -723,9 +570,9 @@
msgstr "<literal>SchemaUpdate</literal> 命令行选项"
#. Tag: entry
-#, fuzzy, no-c-format
+#, no-c-format
msgid "do not export the script to the database"
-msgstr "不把脚本输出到数据库"
+msgstr "不把脚本输出到数据库 "
#. Tag: entry
#, no-c-format
@@ -733,9 +580,9 @@
msgstr "指定一个 <literal>.cfg.xml</literal> 文件"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "You can embed <literal>SchemaUpdate</literal> in your application:"
-msgstr "你可以在你的应用程序中嵌入 <literal>SchemaUpdate</literal> 工具："
+msgstr "你可以在你的应用程序中嵌入 <literal>SchemaUpdate</literal> 工具： "
#. Tag: title
#, no-c-format
@@ -753,35 +600,19 @@
msgstr "Schema 校验"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>SchemaValidator</literal> tool will validate that the existing "
-"database schema \"matches\" your mapping documents. The "
-"<literal>SchemaValidator</literal> depends heavily upon the JDBC metadata "
-"API and, as such, will not work with all JDBC drivers. This tool is "
-"extremely useful for testing."
-msgstr ""
-"<literal>SchemaValidator</literal> 工具会比较数据库现状是否与映射文档“匹配”。"
-"注意，<literal>SchemaValidator</literal> 严重依赖于 JDBC 的 metadata API，因"
-"此不是对所有的 JDBC 驱动都适用。这一工具在测试的时候特别有用。"
+#, no-c-format
+msgid "The <literal>SchemaValidator</literal> tool will validate that the existing database schema \"matches\" your mapping documents. The <literal>SchemaValidator</literal> depends heavily upon the JDBC metadata API and, as such, will not work with all JDBC drivers. This tool is extremely useful for testing."
+msgstr "<literal>SchemaValidator</literal> 工具会比较数据库现状是否与映射文档“匹配”。注意，<literal>SchemaValidator</literal> 严重依赖于 JDBC 的 metadata API，因此不是对所有的 JDBC 驱动都适用。这一工具在测试的时候特别有用。 "
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> "
-"<literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> "
-"<emphasis>options mapping_files</emphasis>"
-msgstr ""
-"<literal>java -cp </literal><emphasis>hibernate_classpaths</"
-"emphasis><literal>org.hibernate.tool.hbm2ddl.SchemaValidator</"
-"literal><emphasis>options mapping_files</emphasis>"
+#, no-c-format
+msgid "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
+msgstr "<literal>java -cp </literal><emphasis>hibernate_classpaths</emphasis> <literal>org.hibernate.tool.hbm2ddl.SchemaValidator</literal> <emphasis>options mapping_files</emphasis>"
#. Tag: para
-#, fuzzy, no-c-format
-msgid ""
-"The following table displays the <literal>SchemaValidator</literal> command "
-"line options:"
-msgstr "<literal>SchemaValidator</literal> 命令行参数"
+#, no-c-format
+msgid "The following table displays the <literal>SchemaValidator</literal> command line options:"
+msgstr "下表显示了 <literal>SchemaValidator</literal> 命令行参数："
#. Tag: title
#, no-c-format
@@ -789,9 +620,9 @@
msgstr "<literal>SchemaValidator</literal> 命令行参数"
#. Tag: para
-#, fuzzy, no-c-format
+#, no-c-format
msgid "You can embed <literal>SchemaValidator</literal> in your application:"
-msgstr "你可以在你的应用程序中嵌入 <literal>SchemaValidator</literal>："
+msgstr "你可以在你的应用程序中嵌入 <literal>SchemaValidator</literal>： "
#. Tag: title
#, no-c-format
@@ -921,46 +752,32 @@
#~ " ...\n"
#~ " <property name=\"bar\" type=\"float\"/>\n"
#~ "</class>"
-
#~ msgid "length"
#~ msgstr "length"
-
#~ msgid "precision"
#~ msgstr "precision"
-
#~ msgid "scale"
#~ msgstr "scale"
-
#~ msgid "not-null"
#~ msgstr "not-null"
-
#~ msgid "true|false"
#~ msgstr "true|false"
-
#~ msgid "unique"
#~ msgstr "unique"
-
#~ msgid "index"
#~ msgstr "index"
-
#~ msgid "index_name"
#~ msgstr "index_name"
-
#~ msgid "unique-key"
#~ msgstr "unique-key"
-
#~ msgid "unique_key_name"
#~ msgstr "unique_key_name"
-
#~ msgid "foreign-key"
#~ msgstr "foreign-key"
-
#~ msgid "sql-type"
#~ msgstr "sql-type"
-
#~ msgid "default"
#~ msgstr "default"
-
#~ msgid "check"
#~ msgstr "check"
@@ -989,25 +806,18 @@
#~ " <comment>Balance in USD</comment>\n"
#~ " </column>\n"
#~ "</property>"
-
#~ msgid "--quiet"
#~ msgstr "--quiet"
-
#~ msgid "--drop"
#~ msgstr "--drop"
-
#~ msgid "--create"
#~ msgstr "--create"
-
#~ msgid "--text"
#~ msgstr "--text"
-
#~ msgid "--properties=hibernate.properties"
#~ msgstr "--properties=hibernate.properties"
-
#~ msgid "--format"
#~ msgstr "--format"
-
#~ msgid "--delimiter=;"
#~ msgstr "--delimiter=;"
@@ -1018,16 +828,12 @@
#~ msgstr ""
#~ "Configuration cfg = ....;\n"
#~ "new SchemaExport(cfg).create(false, true);"
-
#~ msgid "hibernate.connection.url"
#~ msgstr "hibernate.connection.url"
-
#~ msgid "hibernate.connection.username"
#~ msgstr "hibernate.connection.username"
-
#~ msgid "hibernate.connection.password"
#~ msgstr "hibernate.connection.password"
-
#~ msgid "hibernate.dialect"
#~ msgstr "hibernate.dialect"
@@ -1142,3 +948,4 @@
#~ " </fileset>\n"
#~ " </schemaupdate>\n"
#~ "</target>"
+
More information about the jboss-cvs-commits
mailing list