[jboss-cvs] JBossAS SVN: r96689 - projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Sun Nov 22 18:53:29 EST 2009
Author: xhuang at jboss.com
Date: 2009-11-22 18:53:28 -0500 (Sun, 22 Nov 2009)
New Revision: 96689
Modified:
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po
projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/events.po
Log:
update
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po 2009-11-22 23:50:13 UTC (rev 96688)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/basic_mapping.po 2009-11-22 23:53:28 UTC (rev 96689)
@@ -7,7 +7,7 @@
"Project-Id-Version: basic_mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2009-11-06 10:07+1000\n"
+"PO-Revision-Date: 2009-11-23 09:52+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -1306,9 +1306,9 @@
#. Tag: para
#: basic_mapping.xml:974
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Unfortunately, this approach means that a persistent object is its own identifier. There is no convenient \"handle\" other than the object itself. You must instantiate an instance of the persistent class itself and populate its identifier properties before you can <literal>load()</literal> the persistent state associated with a composite key. We call this approach an <emphasis>embedded</emphasis> composite identifier, and discourage it for serious applications."
-msgstr "不幸的是，这种组合关键字的方法意味着一个持久化类是它自己的标识。除了对象自己之外，没有什么方便的“把手”可用。你必须初始化持久化类的实例，填充它的标识符属性，再 <literal>load()</literal> 组合关键字关联的持久状态。我们把这种方法称为 <emphasis>embedded（嵌入式）</emphasis>的组合标识符，在重要的应用中不鼓励使用这种用法。"
+msgstr "不幸的是，这种组合关键字的方法意味着一个持久化类是它自己的标识。除了对象自己之外，没有什么方便的“把手”可用。你必须初始化持久化类的实例，填充它的标识符属性，再 <literal>load()</literal> 组合关键字关联的持久状态。我们把这种方法称为 <emphasis>embedded（嵌入式）</emphasis>的组合标识符，在重要的应用中不鼓励使用这种用法。 "
#. Tag: para
#: basic_mapping.xml:983
@@ -1318,23 +1318,23 @@
#. Tag: programlisting
#: basic_mapping.xml:989
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
" <key-property name=\"medicareNumber\"/>\n"
" <key-property name=\"dependent\"/>\n"
"</composite-id>]]>"
msgstr ""
-"<composite-id class=\"MedicareId\" mapped=\"true\">\n"
-" <key-property name=\"medicareNumber\"/>\n"
-" <key-property name=\"dependent\"/>\n"
-"</composite-id>"
+"<![CDATA[<composite-id class=\"MedicareId\" mapped=\"true\">\n"
+" <key-property name=\"medicareNumber\"/>\n"
+" <key-property name=\"dependent\"/>\n"
+"</composite-id>]]>"
#. Tag: para
#: basic_mapping.xml:991
-#, fuzzy, no-c-format
+#, no-c-format
msgid "In this example, both the composite identifier class, <literal>MedicareId</literal>, and the entity class itself have properties named <literal>medicareNumber</literal> and <literal>dependent</literal>. The identifier class must override <literal>equals()</literal> and <literal>hashCode()</literal> and implement <literal>Serializable</literal>. The main disadvantage of this approach is code duplication."
-msgstr "在这个例子中，组合标识符类 <literal>MedicareId</literal> 和实体类都含有 <literal>medicareNumber</literal> 和 <literal>dependent</literal> 属性。标识符类必须重载 <literal>equals()</literal> 和 <literal>hashCode()</literal> 并且实现 <literal>Serializable</literal> 接口。这种方法的缺点是出现了明显的代码重复。"
+msgstr "在这个例子中，组合标识符类 <literal>MedicareId</literal> 和实体类都含有 <literal>medicareNumber</literal> 和 <literal>dependent</literal> 属性。标识符类必须重载 <literal>equals()</literal> 和 <literal>hashCode()</literal> 并且实现 <literal>Serializable</literal> 接口。这种方法的缺点是出现了明显的代码重复。"
#. Tag: para
#: basic_mapping.xml:1000
@@ -1344,27 +1344,27 @@
#. Tag: para
#: basic_mapping.xml:1006
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>mapped</literal> (optional - defaults to <literal>false</literal>): indicates that a mapped composite identifier is used, and that the contained property mappings refer to both the entity class and the composite identifier class."
-msgstr "<literal>mapped</literal>（可选，默认为 <literal>false</literal>）：指明使用一个映射式组合标识符，其包含的属性映射同时在实体类和组合标识符类中出现。"
+msgstr "<literal>mapped</literal>（可选，默认为 <literal>false</literal>）：指明使用一个映射式组合标识符，其包含的属性映射同时在实体类和组合标识符类中出现。 "
#. Tag: para
#: basic_mapping.xml:1014
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>class</literal> (optional - but required for a mapped composite identifier): the class used as a composite identifier."
-msgstr "<literal>class</literal>（可选,但对映射式组合标识符必须指定）：作为组合标识符类使用的类名."
+msgstr "<literal>class</literal>（可选,但对映射式组合标识符必须指定）：作为组合标识符类使用的类名。"
#. Tag: para
#: basic_mapping.xml:1021
-#, fuzzy, no-c-format
+#, no-c-format
msgid "We will describe a third, even more convenient approach, where the composite identifier is implemented as a component class in <xref linkend=\"components-compositeid\"/>. The attributes described below apply only to this alternative approach:"
-msgstr "在 <xref linkend=\"Component_Mapping-Components_as_composite_identifiers\"/> 一节中,我们会描述第三种方式,那就是把组合标识符实现为一个组件（component）类,这是更方便的方法。下面的属性仅对第三种方法有效："
+msgstr "在 <xref linkend=\"components-compositeid\"/> 一节中,我们会描述第三种方式,那就是把组合标识符实现为一个组件（component）类,这是更方便的方法。下面的属性仅对第三种方法有效："
#. Tag: para
#: basic_mapping.xml:1029
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>name</literal> (optional - required for this approach): a property of component type that holds the composite identifier. Please see chapter 9 for more information."
-msgstr "<literal>name</literal>（可选,但对这种方法而言必须）：包含此组件标识符的组件类型的名字（参阅第9章）。"
+msgstr "<literal>name</literal>（可选,但对这种方法而言必须）：包含此组件标识符的组件类型的名字（参阅第 9 章）。"
#. Tag: para
#: basic_mapping.xml:1035
@@ -1374,37 +1374,37 @@
#: basic_mapping.xml:1731
#: basic_mapping.xml:1901
#: basic_mapping.xml:2480
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate uses for accessing the property value."
-msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。"
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。 "
#. Tag: para
#: basic_mapping.xml:1041
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>class</literal> (optional - defaults to the property type determined by reflection): the component class used as a composite identifier. Please see the next section for more information."
-msgstr "<literal>class</literal>（可选 — 默认会用反射来自动判定属性类型 ）：用来作为组合标识符的组件类的类名（参阅下一节）"
+msgstr "<literal>class</literal>（可选 — 默认会用反射来自动判定属性类型 ）：用来作为组合标识符的组件类的类名（参阅下一节）。 "
#. Tag: para
#: basic_mapping.xml:1048
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The third approach, an <emphasis>identifier component</emphasis>, is recommended for almost all applications."
-msgstr "第三种方式，被称为 <emphasis>identifier component（标识符组件）</emphasis>是我们对几乎所有应用都推荐使用的方式。"
+msgstr "第三种方式，被称为 <emphasis>identifier component（标识符组件）</emphasis>是我们对几乎所有应用都推荐使用的方式。 "
#. Tag: title
#: basic_mapping.xml:1056
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Discriminator"
-msgstr "鉴别器（discriminator）"
+msgstr "鉴别器（discriminator） "
#. Tag: para
#: basic_mapping.xml:1058
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The <literal><discriminator></literal> element is required for polymorphic persistence using the table-per-class-hierarchy mapping strategy. It declares a discriminator column of the table. The discriminator column contains marker values that tell the persistence layer what subclass to instantiate for a particular row. A restricted set of types can be used: <literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>."
-msgstr "在\"一棵对象继承树对应一个表\"的策略中，<literal><discriminator></literal> 元素是必需的，它定义了表的鉴别器字段。鉴别器字段包含标志值，用于告知持久化层应该为某个特定的行创建哪一个子类的实例。如下这些受到限制的类型可以使用：<literal>string</literal>, <literal>character</literal>, <literal>integer</literal>, <literal>byte</literal>, <literal>short</literal>, <literal>boolean</literal>, <literal>yes_no</literal>, <literal>true_false</literal>。"
+msgstr "在\"一棵对象继承树对应一个表\"的策略中，<literal><discriminator></literal> 元素是必需的，它定义了表的鉴别器字段。鉴别器字段包含标志值，用于告知持久化层应该为某个特定的行创建哪一个子类的实例。如下这些受到限制的类型可以使用：<literal>string</literal>、<literal>character</literal>、<literal>integer</literal>、<literal>byte</literal>、<literal>short</literal>、<literal>boolean</literal>、<literal>yes_no</literal>、<literal>true_false</literal>。"
#. Tag: programlisting
#: basic_mapping.xml:1076
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<discriminator\n"
" column=\"discriminator_column\"\n"
@@ -1414,43 +1414,43 @@
" formula=\"arbitrary sql expression\"\n"
"/>]]>"
msgstr ""
-"<discriminator\n"
+"<![CDATA[<discriminator\n"
" column=\"discriminator_column\"\n"
" type=\"discriminator_type\"\n"
" force=\"true|false\"\n"
" insert=\"true|false\"\n"
" formula=\"arbitrary sql expression\"\n"
-"/>"
+"/>]]>"
#. Tag: para
#: basic_mapping.xml:1079
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>column</literal> (optional - defaults to <literal>class</literal>): the name of the discriminator column."
-msgstr "<literal>column</literal>（可选 — 默认为 <literal>class</literal>）器字段的名字"
+msgstr "<literal>column</literal>（可选 — 默认为 <literal>class</literal>）discriminator 器字段的名字。"
#. Tag: para
#: basic_mapping.xml:1085
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>type</literal> (optional - defaults to <literal>string</literal>): a name that indicates the Hibernate type"
-msgstr "<literal>type</literal>（可选 — 默认为 <literal>string</literal>）一个 Hibernate 字段类型的名字"
+msgstr "<literal>type</literal>（可选 — 默认为 <literal>string</literal>）一个 Hibernate 字段类型的名字 "
#. Tag: para
#: basic_mapping.xml:1091
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>force</literal> (optional - defaults to <literal>false</literal>): \"forces\" Hibernate to specify the allowed discriminator values, even when retrieving all instances of the root class."
-msgstr "<literal>force(强制)</literal>（可选 — 默认为 <literal>false</literal>）\"强制\" Hibernate 指定允许的鉴别器值,即使当取得的所有实例都是根类的。"
+msgstr "<literal>force(强制)</literal>（可选 — 默认为 <literal>false</literal>）\"强制\" Hibernate 指定允许的鉴别器值,即使当取得的所有实例都是根类的。 "
#. Tag: para
#: basic_mapping.xml:1098
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): set this to <literal>false</literal> if your discriminator column is also part of a mapped composite identifier. It tells Hibernate not to include the column in SQL <literal>INSERTs</literal>."
-msgstr "<literal>insert</literal>（可选 - 默认为<literal>true</literal>）如果你的鉴别器字段也是映射为复合标识（composite identifier）的一部分，则需将这个值设为 <literal>false</literal>。（告诉 Hibernate 在做 SQL <literal>INSERT</literal> 时不包含该列）"
+msgstr "<literal>insert</literal>（可选 - 默认为<literal>true</literal>）如果你的鉴别器字段也是映射为复合标识（composite identifier）的一部分，则需将这个值设为 <literal>false</literal>。（告诉 Hibernate 在做 SQL <literal>INSERT</literal> 时不包含该列） "
#. Tag: para
#: basic_mapping.xml:1106
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>formula</literal> (optional): an arbitrary SQL expression that is executed when a type has to be evaluated. It allows content-based discrimination."
-msgstr "<literal>formula</literal>（可选）一个 SQL 表达式，在类型判断（判断是父类还是具体子类 — 译注）时执行。可用于基于内容的鉴别器。"
+msgstr "<literal>formula</literal>（可选）一个 SQL 表达式，在类型判断（判断是父类还是具体子类 — 译注）时执行。可用于基于内容的鉴别器。 "
#. Tag: para
#: basic_mapping.xml:1114
@@ -1460,43 +1460,43 @@
#. Tag: para
#: basic_mapping.xml:1120
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The <literal>force</literal> attribute is only useful if the table contains rows with \"extra\" discriminator values that are not mapped to a persistent class. This will not usually be the case."
-msgstr "<literal>force</literal> 属性仅仅在这种情况下有用的：表中包含没有被映射到持久化类的附加辨别器值。这种情况不会经常遇到。"
+msgstr "<literal>force</literal> 属性仅仅在这种情况下有用的：表中包含没有被映射到持久化类的附加辨别器值。这种情况不会经常遇到。 "
#. Tag: para
#: basic_mapping.xml:1126
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The <literal>formula</literal> attribute allows you to declare an arbitrary SQL expression that will be used to evaluate the type of a row. For example:"
-msgstr "使用 <literal>formula</literal> 属性你可以定义一个 SQL 表达式，用来判断一个行数据的类型。"
+msgstr "使用 <literal>formula</literal> 属性你可以定义一个 SQL 表达式，用来判断一行数据的类型。"
#. Tag: programlisting
#: basic_mapping.xml:1131
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<discriminator\n"
" formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
" type=\"integer\"/>]]>"
msgstr ""
-"<discriminator\n"
+"<![CDATA[<discriminator\n"
" formula=\"case when CLASS_TYPE in ('a', 'b', 'c') then 0 else 1 end\"\n"
-" type=\"integer\"/>"
+" type=\"integer\"/>]]>"
#. Tag: title
#: basic_mapping.xml:1136
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Version (optional)"
-msgstr "版本（version）（可选）"
+msgstr "版本（version）（可选） "
#. Tag: para
#: basic_mapping.xml:1138
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The <literal><version></literal> element is optional and indicates that the table contains versioned data. This is particularly useful if you plan to use <emphasis>long transactions</emphasis>. See below for more information:"
-msgstr "<literal><version></literal> 元素是可选的，表明表中包含附带版本信息的数据。这在你准备使用<emphasis> 长事务（long transactions）</emphasis>的时候特别有用。（见后）"
+msgstr "<literal><version></literal> 元素是可选的，表明表中包含附带版本信息的数据。这在你准备使用<emphasis> 长事务（long transactions）</emphasis>的时候特别有用。下面是更多信息："
#. Tag: programlisting
#: basic_mapping.xml:1154
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<version\n"
" column=\"version_column\"\n"
@@ -1509,7 +1509,7 @@
" node=\"element-name|@attribute-name|element/@attribute|.\"\n"
"/>]]>"
msgstr ""
-"<version\n"
+"<![CDATA[<version\n"
" column=\"version_column\"\n"
" name=\"propertyName\"\n"
" type=\"typename\"\n"
@@ -1518,77 +1518,77 @@
" generated=\"never|always\"\n"
" insert=\"true|false\"\n"
" node=\"element-name|@attribute-name|element/@attribute|.\"\n"
-"/>"
+"/>]]>"
#. Tag: para
#: basic_mapping.xml:1157
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>column</literal> (optional - defaults to the property name): the name of the column holding the version number."
-msgstr "<literal>column</literal>（可选 — 默认为属性名）：指定持有版本号的字段名。"
+msgstr "<literal>column</literal>（可选 — 默认为属性名）：指定持有版本号的字段名。 "
#. Tag: para
#: basic_mapping.xml:1163
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>name</literal>: the name of a property of the persistent class."
-msgstr "<literal>name</literal>：持久化类的属性名。"
+msgstr "<literal>name</literal>：持久化类的属性名。 "
#. Tag: para
#: basic_mapping.xml:1168
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>type</literal> (optional - defaults to <literal>integer</literal>): the type of the version number."
-msgstr "<literal>type</literal>（可选 — 默认是 <literal>integer</literal>）：版本号的类型。"
+msgstr "<literal>type</literal>（可选 — 默认是 <literal>integer</literal>）：版本号的类型。 "
#. Tag: para
#: basic_mapping.xml:1174
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>access</literal> (optional - defaults to <literal>property</literal>): the strategy Hibernate uses to access the property value."
-msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。"
+msgstr "<literal>access</literal>（可选 — 默认为 <literal>property</literal>）：Hibernate 用来访问属性值的策略。 "
#. Tag: para
#: basic_mapping.xml:1180
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>undefined</literal>): a version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. <literal>Undefined</literal> specifies that the identifier property value should be used."
-msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>undefined</literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种情况 和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> 指明应被使用的标识属性值。）"
+msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>undefined</literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种情况 和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> 指明应被使用的标识属性值。） "
#. Tag: para
#: basic_mapping.xml:1189
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this version property value is generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/> for more information."
-msgstr "<literal>generated</literal>（可选 — 默认是 <literal>never</literal>）：表明此版本属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-Generated_Properties\"/> 部分的讨论。"
+msgstr "<literal>generated</literal>（可选 — 默认是 <literal>never</literal>）：表明此版本属性值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-generated\"/> 部分的讨论。"
#. Tag: para
#: basic_mapping.xml:1196
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>insert</literal> (optional - defaults to <literal>true</literal>): specifies whether the version column should be included in SQL insert statements. It can be set to <literal>false</literal> if the database column is defined with a default value of <literal>0</literal>."
-msgstr "<literal>insert</literal>（可选 — 默认是 <literal>true</literal>）：表明此版本列应该包含在 SQL 插入语句中。只有当数据库字段有默认值 <literal>0</literal> 的时候，才可以设置为 <literal>false</literal>。"
+msgstr "<literal>insert</literal>（可选 — 默认是 <literal>true</literal>）：表明此版本列应该包含在 SQL 插入语句中。只有当数据库字段有默认值 <literal>0</literal> 的时候，才可以设置为 <literal>false</literal>。 "
#. Tag: para
#: basic_mapping.xml:1206
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Version numbers can be of Hibernate type <literal>long</literal>, <literal>integer</literal>, <literal>short</literal>, <literal>timestamp</literal> or <literal>calendar</literal>."
-msgstr "版本号必须是以下类型：<literal>long</literal>，<literal>integer</literal>，<literal>short</literal>，<literal>timestamp</literal> 或者 <literal>calendar</literal>。"
+msgstr "版本号必须是以下类型：<literal>long</literal>、<literal>integer</literal>、<literal>short</literal>、<literal>timestamp</literal> 或者 <literal>calendar</literal>。"
#. Tag: para
#: basic_mapping.xml:1211
-#, fuzzy, no-c-format
+#, no-c-format
msgid "A version or timestamp property should never be null for a detached instance. Hibernate will detect any instance with a null version or timestamp as transient, irrespective of what other <literal>unsaved-value</literal> strategies are specified. <emphasis>Declaring a nullable version or timestamp property is an easy way to avoid problems with transitive reattachment in Hibernate. It is especially useful for people using assigned identifiers or composite keys</emphasis>."
-msgstr "一个脱管（detached）实例的 version 或 timestamp 属性不能为空（null），因为 Hibernate 不管 <literal>unsaved-value</literal> 被指定为何种策略，它将任何属性为空的 version 或 timestamp 实例看作为瞬时（transient）实例。 <emphasis>避免 Hibernate 中的传递重附（transitive reattachment）问题的一个简单方法是 定义一个不能为空的 version 或 timestamp 属性，特别是在人们使用程序分配的标识符（assigned identifiers） 或复合主键时非常有用！</emphasis>"
+msgstr "一个脱管（detached）实例的 version 或 timestamp 属性不能为空（null），因为 Hibernate 不管 <literal>unsaved-value</literal> 被指定为何种策略，它将任何属性为空的 version 或 timestamp 实例看作为瞬时（transient）实例。 <emphasis>避免 Hibernate 中的传递重附（transitive reattachment）问题的一个简单方法是 定义一个不能为空的 version 或 timestamp 属性，特别是在人们使用程序分配的标识符（assigned identifiers） 或复合主键时非常有用</emphasis>。"
#. Tag: title
#: basic_mapping.xml:1222
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Timestamp (optional)"
-msgstr "timestamp（可选)"
+msgstr "timestamp（可选) "
#. Tag: para
#: basic_mapping.xml:1224
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The optional <literal><timestamp></literal> element indicates that the table contains timestamped data. This provides an alternative to versioning. Timestamps are a less safe implementation of optimistic locking. However, sometimes the application might use the timestamps in other ways."
-msgstr "可选的 <literal><timestamp></literal> 元素指明了表中包含时间戳数据。这用来作为版本的替代。时间戳本质上是一种对乐观锁定的一种不是特别安全的实现。当然，有时候应用程序可能在其他方面使用时间戳。"
+msgstr "可选的 <literal><timestamp></literal> 元素指明了表中包含时间戳数据。这用来作为版本的替代。时间戳本质上是一种对乐观锁定的一种不是特别安全的实现。当然，有时候应用程序可能在其他方面使用时间戳。 "
#. Tag: programlisting
#: basic_mapping.xml:1240
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<timestamp\n"
" column=\"timestamp_column\"\n"
@@ -1600,7 +1600,7 @@
" node=\"element-name|@attribute-name|element/@attribute|.\"\n"
"/>]]>"
msgstr ""
-"<timestamp\n"
+"<![CDATA[<timestamp\n"
" column=\"timestamp_column\"\n"
" name=\"propertyName\"\n"
" access=\"field|property|ClassName\"\n"
@@ -1608,37 +1608,37 @@
" source=\"vm|db\"\n"
" generated=\"never|always\"\n"
" node=\"element-name|@attribute-name|element/@attribute|.\"\n"
-"/>"
+"/>]]>"
#. Tag: para
#: basic_mapping.xml:1243
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>column</literal> (optional - defaults to the property name): the name of a column holding the timestamp."
-msgstr "<literal>column</literal>（可选 — 默认为属性名）：持有时间戳的字段名。"
+msgstr "<literal>column</literal>（可选 — 默认为属性名）：存有时间戳的字段名。 "
#. Tag: para
#: basic_mapping.xml:1249
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>name</literal>: the name of a JavaBeans style property of Java type <literal>Date</literal> or <literal>Timestamp</literal> of the persistent class."
-msgstr "<literal>name</literal>：在持久化类中的 JavaBeans 风格的属性名，其 Java 类型是 <literal>Date</literal> 或者 <literal>Timestamp</literal> 的。"
+msgstr "<literal>name</literal>：在持久化类中的 JavaBeans 风格的属性名，其 Java 类型是 <literal>Date</literal> 或者 <literal>Timestamp</literal> 的。 "
#. Tag: para
#: basic_mapping.xml:1262
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>unsaved-value</literal> (optional - defaults to <literal>null</literal>): a version property value that indicates that an instance is newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session. <literal>Undefined</literal> specifies that the identifier property value should be used."
-msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>null</literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种情况和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> 指明使用标识属性值进行这种判断。）"
+msgstr "<literal>unsaved-value</literal>（可选 — 默认是 <literal>null</literal>）：用于标明某个实例时刚刚被实例化的（尚未保存）版本属性值，依靠这个值就可以把这种情况和已经在先前的 session 中保存或装载的脱管（detached）实例区分开来。（<literal>undefined</literal> 指明使用标识属性值进行这种判断。） "
#. Tag: para
#: basic_mapping.xml:1271
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>source</literal> (optional - defaults to <literal>vm</literal>): Where should Hibernate retrieve the timestamp value from? From the database, or from the current JVM? Database-based timestamps incur an overhead because Hibernate must hit the database in order to determine the \"next value\". It is safer to use in clustered environments. Not all <literal>Dialects</literal> are known to support the retrieval of the database's current timestamp. Others may also be unsafe for usage in locking due to lack of precision (Oracle 8, for example)."
-msgstr "<literal>source</literal>（可选 — 默认是 <literal>vm</literal>）：Hibernate 如何才能获取到时间戳的值呢？从数据库，还是当前 JVM？从数据库获取会带来一些负担，因为 Hibernate 必须访问数据库来获得“下一个值”，但是在集群环境中会更安全些。还要注意，并不是所有的 <literal>Dialect（方言）</literal>都支持获得数据库的当前时间戳的，而支持的数据库中又有一部分因为精度不足，用于锁定是不安全的（例如 Oracle 8）。"
+msgstr "<literal>source</literal>（可选 — 默认是 <literal>vm</literal>）：Hibernate 如何才能获取到时间戳的值呢？从数据库，还是当前 JVM？从数据库获取会带来一些负担，因为 Hibernate 必须访问数据库来获得“下一个值”，但是在集群环境中会更安全些。还要注意，并不是所有的 <literal>Dialect（方言）</literal>都支持获得数据库的当前时间戳的，而支持的数据库中又有一部分因为精度不足，用于锁定是不安全的（例如 Oracle 8）。 "
#. Tag: para
#: basic_mapping.xml:1283
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal>generated</literal> (optional - defaults to <literal>never</literal>): specifies that this timestamp property value is actually generated by the database. See the discussion of <xref linkend=\"mapping-generated\"/> for more information."
-msgstr "<literal>generated</literal>（可选 - 默认是 <literal>never</literal>）：指出时间戳值是否实际上是由数据库生成的。请参阅 <xref linkend=\"Basic_OR_Mapping-Generated_Properties\"/> 的讨论。"
+msgstr "<literal>generated</literal>（可选 - 默认是 <literal>never</literal>）：指出时间戳值是否实际上是由数据库生成的。请参阅 <xref linkend=\"mapping-generated\"/> 的讨论。"
#. Tag: title
#: basic_mapping.xml:1294
@@ -1649,25 +1649,25 @@
#. Tag: para
#: basic_mapping.xml:1295
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<literal><Timestamp></literal> is equivalent to <literal><version type=\"timestamp\"></literal>. And <literal><timestamp source=\"db\"></literal> is equivalent to <literal><version type=\"dbtimestamp\"></literal>"
-msgstr "注意，<literal><timestamp></literal> 和 <literal><version type=\"timestamp\"></literal> 是等价的。并且 <literal><timestamp source=\"db\"></literal> 和 <literal><version type=\"dbtimestamp\"></literal> 是等价的。"
+msgstr "注意，<literal><timestamp></literal> 和 <literal><version type=\"timestamp\"></literal> 是等价的。并且 <literal><timestamp source=\"db\"></literal> 和 <literal><version type=\"dbtimestamp\"></literal> 是等价的。 "
#. Tag: title
#: basic_mapping.xml:1307
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Property"
-msgstr "property"
+msgstr "Property"
#. Tag: para
#: basic_mapping.xml:1309
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The <literal><property></literal> element declares a persistent JavaBean style property of the class."
-msgstr "<literal><property></literal> 元素为类定义了一个持久化的、JavaBean 风格的属性。"
+msgstr "<literal><property></literal> 元素为类定义了一个持久化的、JavaBean 风格的属性。 "
#. Tag: programlisting
#: basic_mapping.xml:1331
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<property\n"
" name=\"propertyName\"\n"
@@ -1690,7 +1690,7 @@
" scale=\"S\"\n"
"/>]]>"
msgstr ""
-"<property\n"
+"<![CDATA[<property\n"
" name=\"propertyName\"\n"
" column=\"column_name\"\n"
" type=\"typename\"\n"
@@ -1709,7 +1709,7 @@
" length=\"L\"\n"
" precision=\"P\"\n"
" scale=\"S\"\n"
-"/>"
+"/>]]>"
#. Tag: para
#: basic_mapping.xml:1334
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po 2009-11-22 23:50:13 UTC (rev 96688)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/batch.po 2009-11-22 23:53:28 UTC (rev 96689)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-23 09:45+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,16 +22,13 @@
#. Tag: para
#: batch.xml:31
-#, fuzzy, no-c-format
-msgid ""
-"A naive approach to inserting 100,000 rows in the database using Hibernate "
-"might look like this:"
-msgstr ""
-"使用 Hibernate 将 100 000 条记录插入到数据库的一个很自然的做法可能是这样的："
+#, no-c-format
+msgid "A naive approach to inserting 100,000 rows in the database using Hibernate might look like this:"
+msgstr "使用 Hibernate 将 100,000 条记录插入到数据库的一个很天真的做法可能是这样的："
#. Tag: programlisting
#: batch.xml:36
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
@@ -42,82 +39,56 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
-"for ( int i=0; i<100000; i++ ) {\n"
+"for ( int i=0; i<100000; i++ ) {\n"
" Customer customer = new Customer(.....);\n"
" session.save(customer);\n"
"}\n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: para
#: batch.xml:38
-#, fuzzy, no-c-format
-msgid ""
-"This would fall over with an <literal>OutOfMemoryException</literal> "
-"somewhere around the 50,000th row. That is because Hibernate caches all the "
-"newly inserted <literal>Customer</literal> instances in the session-level "
-"cache. In this chapter we will show you how to avoid this problem."
-msgstr ""
-"这段程序大概运行到 50 000 条记录左右会失败并抛出<literal>内存溢出异常"
-"（OutOfMemoryException）</literal> 。这是因为 Hibernate 把所有新插入的"
-"<literal>客户（Customer）</literal>实例在 session 级别的缓存区进行了缓存的缘"
-"故。"
+#, no-c-format
+msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50,000th row. That is because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache. In this chapter we will show you how to avoid this problem."
+msgstr "这段程序大概运行到 50，000 条记录左右会失败并抛出<literal>内存溢出异常（OutOfMemoryException）</literal> 。这是因为 Hibernate 把所有新插入的<literal>客户（Customer）</literal>实例在 session 级别的缓存区进行了缓存的缘故。 "
#. Tag: para
#: batch.xml:45
-#, fuzzy, no-c-format
-msgid ""
-"If you are undertaking batch processing you will need to enable the use of "
-"JDBC batching. This is absolutely essential if you want to achieve optimal "
-"performance. Set the JDBC batch size to a reasonable number (10-50, for "
-"example):"
-msgstr ""
-"我们会在本章告诉你如何避免此类问题。首先，如果你要执行批量处理并且想要达到一"
-"个理想的性能， 那么使用 JDBC 的批量（batching）功能是至关重要。将 JDBC 的批量"
-"抓取数量（batch size）参数设置到一个合适值 （比如，10 - 50 之间）："
+#, no-c-format
+msgid "If you are undertaking batch processing you will need to enable the use of JDBC batching. This is absolutely essential if you want to achieve optimal performance. Set the JDBC batch size to a reasonable number (10-50, for example):"
+msgstr "我们会在本章告诉你如何避免此类问题。首先，如果你要执行批量处理并且想要达到一个理想的性能，那么使用 JDBC 的批量（batching）功能是至关重要。将 JDBC 的批量抓取数量（batch size）参数设置到一个合适值（比如，10 - 50 之间）："
#. Tag: programlisting
#: batch.xml:52
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<![CDATA[hibernate.jdbc.batch_size 20]]>"
-msgstr "hibernate.jdbc.batch_size 20"
+msgstr "<![CDATA[hibernate.jdbc.batch_size 20]]>"
#. Tag: para
#: batch.xml:54
-#, fuzzy, no-c-format
-msgid ""
-"Hibernate disables insert batching at the JDBC level transparently if you "
-"use an <literal>identity</literal> identifier generator."
-msgstr ""
-"注意，假若你使用了 <literal>identiy</literal> 标识符生成器，Hibernate 在 "
-"JDBC 级别透明的关闭插入语句的批量执行。"
+#, no-c-format
+msgid "Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identity</literal> identifier generator."
+msgstr "注意，假若你使用了 <literal>identiy</literal> 标识符生成器，Hibernate 在 JDBC 级别透明的关闭插入语句的批量执行。 "
#. Tag: para
#: batch.xml:59
-#, fuzzy, no-c-format
-msgid ""
-"You can also do this kind of work in a process where interaction with the "
-"second-level cache is completely disabled:"
-msgstr "你也可能想在执行批量处理时关闭二级缓存："
+#, no-c-format
+msgid "You can also do this kind of work in a process where interaction with the second-level cache is completely disabled:"
+msgstr "你也可能想在执行批量处理时完全关闭二级缓存："
#. Tag: programlisting
#: batch.xml:64
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
-msgstr "hibernate.cache.use_second_level_cache false"
+msgstr "<![CDATA[hibernate.cache.use_second_level_cache false]]>"
#. Tag: para
#: batch.xml:66
#, no-c-format
-msgid ""
-"However, this is not absolutely necessary, since we can explicitly set the "
-"<literal>CacheMode</literal> to disable interaction with the second-level "
-"cache."
-msgstr ""
-"但是，这不是绝对必须的，因为我们可以显式设置 <literal>CacheMode</literal> 来"
-"关闭与二级缓存的交互。"
+msgid "However, this is not absolutely necessary, since we can explicitly set the <literal>CacheMode</literal> to disable interaction with the second-level cache."
+msgstr "但是，这不是绝对必须的，因为我们可以显式设置 <literal>CacheMode</literal> 来关闭与二级缓存的交互。"
#. Tag: title
#: batch.xml:72
@@ -127,18 +98,13 @@
#. Tag: para
#: batch.xml:74
-#, fuzzy, no-c-format
-msgid ""
-"When making new objects persistent <literal>flush()</literal> and then "
-"<literal>clear()</literal> the session regularly in order to control the "
-"size of the first-level cache."
-msgstr ""
-"如果要将很多对象持久化，你必须通过经常的调用 <literal>flush()</literal> 以及"
-"稍后调用 <literal>clear()</literal> 来控制第一级缓存的大小。"
+#, no-c-format
+msgid "When making new objects persistent <literal>flush()</literal> and then <literal>clear()</literal> the session regularly in order to control the size of the first-level cache."
+msgstr "如果要将很多对象持久化，你必须通过经常的调用 <literal>flush()</literal> 以及稍后调用 <literal>clear()</literal> 来控制第一级缓存的大小。 "
#. Tag: programlisting
#: batch.xml:80
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
@@ -156,13 +122,13 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
" \n"
-"for ( int i=0; i<100000; i++ ) {\n"
+"for ( int i=0; i<100000; i++ ) {\n"
" Customer customer = new Customer(.....);\n"
" session.save(customer);\n"
-" if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
+" if ( i % 20 == 0 ) { //20, same as the JDBC batch size\n"
" //flush a batch of inserts and release memory:\n"
" session.flush();\n"
" session.clear();\n"
@@ -170,7 +136,7 @@
"}\n"
" \n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: title
#: batch.xml:85
@@ -180,18 +146,13 @@
#. Tag: para
#: batch.xml:87
-#, fuzzy, no-c-format
-msgid ""
-"For retrieving and updating data, the same ideas apply. In addition, you "
-"need to use <literal>scroll()</literal> to take advantage of server-side "
-"cursors for queries that return many rows of data."
-msgstr ""
-"此方法同样适用于检索和更新数据。此外，在进行会返回很多行数据的查询时，你需要"
-"使用 <literal>scroll()</literal> 方法以便充分利用服务器端游标所带来的好处。"
+#, no-c-format
+msgid "For retrieving and updating data, the same ideas apply. In addition, you need to use <literal>scroll()</literal> to take advantage of server-side cursors for queries that return many rows of data."
+msgstr "此方法同样适用于检索和更新数据。此外，在进行会返回很多行数据的查询时，你需要使用 <literal>scroll()</literal> 方法以便充分利用服务器端游标所带来的好处。 "
#. Tag: programlisting
#: batch.xml:93
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
@@ -213,7 +174,7 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
" \n"
"ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
@@ -223,7 +184,7 @@
"while ( customers.next() ) {\n"
" Customer customer = (Customer) customers.get(0);\n"
" customer.updateStuff(...);\n"
-" if ( ++count % 20 == 0 ) {\n"
+" if ( ++count % 20 == 0 ) {\n"
" //flush a batch of updates and release memory:\n"
" session.flush();\n"
" session.clear();\n"
@@ -231,7 +192,7 @@
"}\n"
" \n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: title
#: batch.xml:98
@@ -241,34 +202,13 @@
#. Tag: para
#: batch.xml:99
-#, fuzzy, no-c-format
-msgid ""
-"Alternatively, Hibernate provides a command-oriented API that can be used "
-"for streaming data to and from the database in the form of detached objects. "
-"A <literal>StatelessSession</literal> has no persistence context associated "
-"with it and does not provide many of the higher-level life cycle semantics. "
-"In particular, a stateless session does not implement a first-level cache "
-"nor interact with any second-level or query cache. It does not implement "
-"transactional write-behind or automatic dirty checking. Operations performed "
-"using a stateless session never cascade to associated instances. Collections "
-"are ignored by a stateless session. Operations performed via a stateless "
-"session bypass Hibernate's event model and interceptors. Due to the lack of "
-"a first-level cache, Stateless sessions are vulnerable to data aliasing "
-"effects. A stateless session is a lower-level abstraction that is much "
-"closer to the underlying JDBC."
-msgstr ""
-"作为选择，Hibernate 提供了基于命令的 API，可以用 detached object 的形式把数据"
-"以流的方法加入到数据库，或从数据库输出。<literal>StatelessSession</literal> "
-"没有持久化上下文，也不提供多少高层的生命周期语义。特别是，无状态 session 不实"
-"现第一级 cache，也不和第二级缓存，或者查询缓存交互。它不实现事务化写，也不实"
-"现脏数据检查。用 stateless session 进行的操作甚至不级联到关联实例。stateless "
-"session 忽略集合类（Collections）。通过 stateless session 进行的操作不触发 "
-"Hibernate 的事件模型和拦截器。无状态 session 对数据的混淆现象免疫，因为它没有"
-"第一级缓存。无状态 session 是低层的抽象，和低层 JDBC 相当接近。"
+#, no-c-format
+msgid "Alternatively, Hibernate provides a command-oriented API that can be used for streaming data to and from the database in the form of detached objects. A <literal>StatelessSession</literal> has no persistence context associated with it and does not provide many of the higher-level life cycle semantics. In particular, a stateless session does not implement a first-level cache nor interact with any second-level or query cache. It does not implement transactional write-behind or automatic dirty checking. Operations performed using a stateless session never cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Due to the lack of a first-level cache, Stateless sessions are vulnerable to data aliasing effects. A stateless session is a lower-level abstraction that is much closer to the underlying JDBC."
+msgstr "作为选择，Hibernate 提供了基于命令的 API，可以用 detached object 的形式把数据以流的方法加入到数据库，或从数据库输出。<literal>StatelessSession</literal> 没有持久化上下文，也不提供多少高层的生命周期语义。特别是，无状态 session 不实现第一级 cache，也不和第二级缓存，或者查询缓存交互。它不实现事务化写，也不实现脏数据检查。用 stateless session 进行的操作甚至不级联到关联实例。stateless session 忽略集合类（Collections）。通过 stateless session 进行的操作不触发 Hibernate 的事件模型和拦截器。无状态 session 对数据的混淆现象免疫，因为它没有第一级缓存。无状态 session 是低层的抽象，和低层 JDBC 相当接近。 "
#. Tag: programlisting
#: batch.xml:114
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
"Transaction tx = session.beginTransaction();\n"
@@ -284,7 +224,7 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"StatelessSession session = sessionFactory.openStatelessSession();\n"
+"<![CDATA[StatelessSession session = sessionFactory.openStatelessSession();\n"
"Transaction tx = session.beginTransaction();\n"
" \n"
"ScrollableResults customers = session.getNamedQuery(\"GetCustomers\")\n"
@@ -296,37 +236,19 @@
"}\n"
" \n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: para
#: batch.xml:116
-#, fuzzy, no-c-format
-msgid ""
-"In this code example, the <literal>Customer</literal> instances returned by "
-"the query are immediately detached. They are never associated with any "
-"persistence context."
-msgstr ""
-"注意在上面的例子中，查询返回的 <literal>Customer</literal> 实例立即被脱管"
-"（detach）。它们与任何持久化上下文都没有关系。"
+#, no-c-format
+msgid "In this code example, the <literal>Customer</literal> instances returned by the query are immediately detached. They are never associated with any persistence context."
+msgstr "注意在上面的例子中，查询返回的 <literal>Customer</literal> 实例立即被脱管（detach）。它们与任何持久化上下文都没有关系。 "
#. Tag: para
#: batch.xml:122
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>insert(), update()</literal> and <literal>delete()</literal> "
-"operations defined by the <literal>StatelessSession</literal> interface are "
-"considered to be direct database row-level operations. They result in the "
-"immediate execution of a SQL <literal>INSERT, UPDATE</literal> or "
-"<literal>DELETE</literal> respectively. They have different semantics to the "
-"<literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> "
-"operations defined by the <literal>Session</literal> interface."
-msgstr ""
-"<literal>StatelessSession</literal> 接口定义的 <literal>insert(), update()</"
-"literal> 和 <literal>delete()</literal> 操作是直接的数据库行级别操作，其结果"
-"是立刻执行一条 <literal>INSERT, UPDATE</literal> 或 <literal>DELETE</"
-"literal> 语句。因此，它们的语义和 <literal>Session</literal> 接口定义的 "
-"<literal>save(), saveOrUpdate()</literal> 和<literal>delete()</literal> 操作"
-"有很大的不同。"
+#, no-c-format
+msgid "The <literal>insert(), update()</literal> and <literal>delete()</literal> operations defined by the <literal>StatelessSession</literal> interface are considered to be direct database row-level operations. They result in the immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. They have different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
+msgstr "<literal>StatelessSession</literal> 接口定义的 <literal>insert(), update()</literal> 和 <literal>delete()</literal> 操作是直接的数据库行级别操作，其结果是立刻执行一条 <literal>INSERT, UPDATE</literal> 或 <literal>DELETE</literal> 语句。因此，它们的语义和 <literal>Session</literal> 接口定义的 <literal>save(), saveOrUpdate()</literal> 和<literal>delete()</literal> 操作有很大的不同。 "
#. Tag: title
#: batch.xml:135
@@ -336,44 +258,21 @@
#. Tag: para
#: batch.xml:137
-#, fuzzy, no-c-format
-msgid ""
-"As already discussed, automatic and transparent object/relational mapping is "
-"concerned with the management of the object state. The object state is "
-"available in memory. This means that manipulating data directly in the "
-"database (using the SQL <literal>Data Manipulation Language</literal> (DML) "
-"the statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, "
-"<literal>DELETE</literal>) will not affect in-memory state. However, "
-"Hibernate provides methods for bulk SQL-style DML statement execution that "
-"is performed through the Hibernate Query Language (<xref linkend=\"queryhql"
-"\"/>)."
-msgstr ""
-"就像已经讨论的那样，自动和透明的对象／关系映射（object/relational mapping）关"
-"注于管理对象的状态。这就意味着对象的状态存在于内存，因此直接操作（使用 SQL "
-"<literal>Data Manipulation Language</literal>（DML,数据操作语言）语句 ："
-"<literal>INSERT</literal> ,<literal>UPDATE</literal> 和 <literal>DELETE</"
-"literal>） 数据库中的数据将不会影响内存中的对象状态和对象数据。不过，"
-"Hibernate 提供通过 Hibernate 查询语言（<xref linkend="
-"\"HQL_The_Hibernate_Query_Language\"/>）来执行大批量 SQL 风格的 DML 语句的方"
-"法。"
+#, no-c-format
+msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of the object state. The object state is available in memory. This means that manipulating data directly in the database (using the SQL <literal>Data Manipulation Language</literal> (DML) the statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution that is performed through the Hibernate Query Language (<xref linkend=\"queryhql\"/>)."
+msgstr "就像已经讨论的那样，自动和透明的对象/关系映射（object/relational mapping）关注于管理对象的状态。这就意味着对象的状态存在于内存，因此直接操作（使用 SQL <literal>Data Manipulation Language</literal>（DML,数据操作语言）语句 ：<literal>INSERT</literal> ,<literal>UPDATE</literal> 和 <literal>DELETE</literal>） 数据库中的数据将不会影响内存中的对象状态和对象数据。不过，Hibernate 提供通过 Hibernate 查询语言（<xref linkend=\"queryhql\"/>）来执行大批量 SQL 风格的 DML 语句的方法。"
#. Tag: para
#: batch.xml:146
-#, fuzzy, no-c-format
-msgid ""
-"The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</"
-"literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE "
-"where_conditions)?</literal>."
-msgstr ""
-"<literal>UPDATE</literal> 和 <literal>DELETE</literal> 语句的语法为："
-"<literal>（ UPDATE | DELETE ） FROM? EntityName （WHERE where_conditions）?</"
-"literal> 有几点说明："
+#, no-c-format
+msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>."
+msgstr "<literal>UPDATE</literal> 和 <literal>DELETE</literal> 语句的伪语法为：<literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>。"
#. Tag: para
#: batch.xml:151
#, no-c-format
msgid "Some points to note:"
-msgstr ""
+msgstr "要注意的事项："
#. Tag: para
#: batch.xml:157
@@ -383,28 +282,15 @@
#. Tag: para
#: batch.xml:162
-#, fuzzy, no-c-format
-msgid ""
-"There can only be a single entity named in the from-clause. It can, however, "
-"be aliased. If the entity name is aliased, then any property references must "
-"be qualified using that alias. If the entity name is not aliased, then it is "
-"illegal for any property references to be qualified."
-msgstr ""
-"在 FROM 子句（from-clause）中只能有一个实体名，它可以是别名。如果实体名是别"
-"名，那么任何被引用的属性都必须加上此别名的前缀；如果不是别名，那么任何有前缀"
-"的属性引用都是非法的。"
+#, no-c-format
+msgid "There can only be a single entity named in the from-clause. It can, however, be aliased. If the entity name is aliased, then any property references must be qualified using that alias. If the entity name is not aliased, then it is illegal for any property references to be qualified."
+msgstr "在 FROM 子句（from-clause）中只能有一个实体名，它可以是别名。如果实体名是别名，那么任何被引用的属性都必须加上此别名的前缀；如果不是别名，那么任何有前缀的属性引用都是非法的。 "
#. Tag: para
#: batch.xml:170
-#, fuzzy, no-c-format
-msgid ""
-"No <xref linkend=\"queryhql-joins-forms\"/>, either implicit or explicit, "
-"can be specified in a bulk HQL query. Sub-queries can be used in the where-"
-"clause, where the subqueries themselves may contain joins."
-msgstr ""
-"不能在大批量 HQL 语句中使用 <xref linkend=\"HQL_The_Hibernate_Query_Language-"
-"Forms_of_join_syntax\"/> 连接（显式或者隐式的都不行）。不过在 WHERE 子句中可"
-"以使用子查询。可以在 where 子句中使用子查询，子查询本身可以包含 join。"
+#, no-c-format
+msgid "No <xref linkend=\"queryhql-joins-forms\"/>, either implicit or explicit, can be specified in a bulk HQL query. Sub-queries can be used in the where-clause, where the subqueries themselves may contain joins."
+msgstr "不能在大批量 HQL 语句中使用 <xref linkend=\"queryhql-joins-forms\"/> 连接（显式或者隐式的都不行）。不过在 WHERE 子句中可以使用子查询。可以在 where 子句中使用子查询，子查询本身可以包含 join。"
#. Tag: para
#: batch.xml:177
@@ -414,28 +300,19 @@
#. Tag: para
#: batch.xml:183
-#, fuzzy, no-c-format
-msgid ""
-"As an example, to execute an HQL <literal>UPDATE</literal>, use the "
-"<literal>Query.executeUpdate()</literal> method. The method is named for "
-"those familiar with JDBC's <literal>PreparedStatement.executeUpdate()</"
-"literal>:"
-msgstr ""
-"举个例子，使用 <literal>Query.executeUpdate()</literal> 方法执行一个 HQL "
-"<literal>UPDATE</literal>语句（方法命名是来源于 JDBC 的 "
-"<literal>PreparedStatement.executeUpdate()</literal>）： "
+#, no-c-format
+msgid "As an example, to execute an HQL <literal>UPDATE</literal>, use the <literal>Query.executeUpdate()</literal> method. The method is named for those familiar with JDBC's <literal>PreparedStatement.executeUpdate()</literal>:"
+msgstr "举个例子，使用 <literal>Query.executeUpdate()</literal> 方法执行一个 HQL <literal>UPDATE</literal>语句（方法命名是来源于 JDBC 的 <literal>PreparedStatement.executeUpdate()</literal>）： "
#. Tag: programlisting
#: batch.xml:189
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
-"String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :"
-"oldName\";\n"
-"// or String hqlUpdate = \"update Customer set name = :newName where name = :"
-"oldName\";\n"
+"String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+"// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
"int updatedEntities = s.createQuery( hqlUpdate )\n"
" .setString( \"newName\", newName )\n"
" .setString( \"oldName\", oldName )\n"
@@ -443,49 +320,31 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
-"String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :"
-"oldName\";\n"
-"// or String hqlUpdate = \"update Customer set name = :newName where name = :"
-"oldName\";\n"
+"String hqlUpdate = \"update Customer c set c.name = :newName where c.name = :oldName\";\n"
+"// or String hqlUpdate = \"update Customer set name = :newName where name = :oldName\";\n"
"int updatedEntities = s.createQuery( hqlUpdate )\n"
" .setString( \"newName\", newName )\n"
" .setString( \"oldName\", oldName )\n"
" .executeUpdate();\n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: para
#: batch.xml:191
-#, fuzzy, no-c-format
-msgid ""
-"In keeping with the EJB3 specification, HQL <literal>UPDATE</literal> "
-"statements, by default, do not effect the <xref linkend=\"mapping-"
-"declaration-version\"/> or the <xref linkend=\"mapping-declaration-timestamp"
-"\"/> property values for the affected entities. However, you can force "
-"Hibernate to reset the <literal>version</literal> or <literal>timestamp</"
-"literal> property values through the use of a <literal>versioned update</"
-"literal>. This is achieved by adding the <literal>VERSIONED</literal> "
-"keyword after the <literal>UPDATE</literal> keyword."
-msgstr ""
-"HQL <literal>UPDATE</literal> 语句，默认不会影响更新实体的 <xref linkend="
-"\"Mapping_declaration-version_optional\"/> 或者 <xref linkend="
-"\"Mapping_declaration-timestamp_optional\"/> 属性值。这和 EJB3 规范是一致的。"
-"但是，通过使用 <literal>versioned update</literal>，你可以强制 Hibernate 正确"
-"的重置<literal>version</literal> 或者 <literal>timestamp</literal> 属性值。这"
-"通过在 <literal>UPDATE</literal> 关键字后面增加 <literal>VERSIONED</literal> "
-"关键字来实现的。"
+#, no-c-format
+msgid "In keeping with the EJB3 specification, HQL <literal>UPDATE</literal> statements, by default, do not effect the <xref linkend=\"mapping-declaration-version\"/> or the <xref linkend=\"mapping-declaration-timestamp\"/> property values for the affected entities. However, you can force Hibernate to reset the <literal>version</literal> or <literal>timestamp</literal> property values through the use of a <literal>versioned update</literal>. This is achieved by adding the <literal>VERSIONED</literal> keyword after the <literal>UPDATE</literal> keyword."
+msgstr "HQL <literal>UPDATE</literal> 语句，默认不会影响更新实体的 <xref linkend=\"mapping-declaration-version\"/> 或者 <xref linkend=\"mapping-declaration-timestamp\"/> 属性值。这和 EJB3 规范是一致的。但是，通过使用 <literal>versioned update</literal>，你可以强制 Hibernate 正确的重置<literal>version</literal> 或者 <literal>timestamp</literal> 属性值。这通过在 <literal>UPDATE</literal> 关键字后面增加 <literal>VERSIONED</literal> 关键字来实现的。"
#. Tag: programlisting
#: batch.xml:201
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
-"String hqlVersionedUpdate = \"update versioned Customer set name = :newName "
-"where name = :oldName\";\n"
+"String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
"int updatedEntities = s.createQuery( hqlUpdate )\n"
" .setString( \"newName\", newName )\n"
" .setString( \"oldName\", oldName )\n"
@@ -493,41 +352,31 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
-"String hqlVersionedUpdate = \"update versioned Customer set name = :newName "
-"where name = :oldName\";\n"
+"String hqlVersionedUpdate = \"update versioned Customer set name = :newName where name = :oldName\";\n"
"int updatedEntities = s.createQuery( hqlUpdate )\n"
" .setString( \"newName\", newName )\n"
" .setString( \"oldName\", oldName )\n"
" .executeUpdate();\n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: para
#: batch.xml:203
-#, fuzzy, no-c-format
-msgid ""
-"Custom version types, <literal>org.hibernate.usertype.UserVersionType</"
-"literal>, are not allowed in conjunction with a <literal>update versioned</"
-"literal> statement."
-msgstr ""
-"注意，自定义的版本类型（<literal>org.hibernate.usertype.UserVersionType</"
-"literal>）不允许和 <literal>update versioned</literal> 语句联用。"
+#, no-c-format
+msgid "Custom version types, <literal>org.hibernate.usertype.UserVersionType</literal>, are not allowed in conjunction with a <literal>update versioned</literal> statement."
+msgstr "注意，自定义的版本类型（<literal>org.hibernate.usertype.UserVersionType</literal>）不允许和 <literal>update versioned</literal> 语句联用。 "
#. Tag: para
#: batch.xml:208
#, no-c-format
-msgid ""
-"To execute an HQL <literal>DELETE</literal>, use the same <literal>Query."
-"executeUpdate()</literal> method:"
-msgstr ""
-"执行一个 HQL <literal>DELETE</literal>，同样使用 <literal>Query.executeUpdate"
-"()</literal> 方法："
+msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
+msgstr "执行一个 HQL <literal>DELETE</literal>，同样使用 <literal>Query.executeUpdate()</literal> 方法："
#. Tag: programlisting
#: batch.xml:213
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
@@ -540,7 +389,7 @@
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
"String hqlDelete = \"delete Customer c where c.name = :oldName\";\n"
@@ -549,165 +398,75 @@
" .setString( \"oldName\", oldName )\n"
" .executeUpdate();\n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
#. Tag: para
#: batch.xml:215
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>int</literal> value returned by the <literal>Query.executeUpdate"
-"()</literal> method indicates the number of entities effected by the "
-"operation. This may or may not correlate to the number of rows effected in "
-"the database. An HQL bulk operation might result in multiple actual SQL "
-"statements being executed (for joined-subclass, for example). The returned "
-"number indicates the number of actual entities affected by the statement. "
-"Going back to the example of joined-subclass, a delete against one of the "
-"subclasses may actually result in deletes against not just the table to "
-"which that subclass is mapped, but also the \"root\" table and potentially "
-"joined-subclass tables further down the inheritance hierarchy."
-msgstr ""
-"由 <literal>Query.executeUpdate()</literal> 方法返回的<literal>整型</literal>"
-"值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条 SQL 语"
-"句）影响了的“行”数有关，也可能没有。一个大批量 HQL 操作可能导致多条实际的SQL"
-"语句被执行，举个例子，对 joined-subclass 映射方式的类进行的此类操作。这个返回"
-"值代表了实际被语句影响了的记录数量。在那个 joined-subclass 的例子中， 对一个"
-"子类的删除实际上可能不仅仅会删除子类映射到的表而且会影响“根”表，还有可能影响"
-"与之有继承关系的 joined-subclass 映射方式的子类的表。"
+#, no-c-format
+msgid "The <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicates the number of entities effected by the operation. This may or may not correlate to the number of rows effected in the database. An HQL bulk operation might result in multiple actual SQL statements being executed (for joined-subclass, for example). The returned number indicates the number of actual entities affected by the statement. Going back to the example of joined-subclass, a delete against one of the subclasses may actually result in deletes against not just the table to which that subclass is mapped, but also the \"root\" table and potentially joined-subclass tables further down the inheritance hierarchy."
+msgstr "由 <literal>Query.executeUpdate()</literal> 方法返回的<literal>整型</literal>值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条 SQL 语句）影响了的“行”数有关，也可能没有。一个大批量 HQL 操作可能导致多条实际的SQL语句被执行，举个例子，对 joined-subclass 映射方式的类进行的此类操作。这个返回值代表了实际被语句影响了的记录数量。在那个 joined-subclass 的例子中， 对一个子类的删除实际上可能不仅仅会删除子类映射到的表而且会影响“根”表，还有可能影响与之有继承关系的 joined-subclass 映射方式的子类的表。 "
#. Tag: para
#: batch.xml:226
#, no-c-format
-msgid ""
-"The pseudo-syntax for <literal>INSERT</literal> statements is: "
-"<literal>INSERT INTO EntityName properties_list select_statement</literal>. "
-"Some points to note:"
-msgstr ""
-"<literal>INSERT</literal> 语句的伪码是：<literal>INSERT INTO EntityName "
-"properties_list select_statement</literal>。要注意的是："
+msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
+msgstr "<literal>INSERT</literal> 语句的伪码是：<literal>INSERT INTO EntityName properties_list select_statement</literal>。要注意的是："
#. Tag: para
#: batch.xml:234
#, no-c-format
-msgid ""
-"Only the INSERT INTO ... SELECT ... form is supported; not the INSERT "
-"INTO ... VALUES ... form."
-msgstr ""
-"只支持 INSERT INTO ... SELECT ... 形式，不支持 INSERT INTO ... VALUES ... 形"
-"式。"
+msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
+msgstr "只支持 INSERT INTO ... SELECT ... 形式，不支持 INSERT INTO ... VALUES ... 形式。"
#. Tag: para
#: batch.xml:237
-#, fuzzy, no-c-format
-msgid ""
-"The properties_list is analogous to the <literal>column specification</"
-"literal> in the SQL <literal>INSERT</literal> statement. For entities "
-"involved in mapped inheritance, only properties directly defined on that "
-"given class-level can be used in the properties_list. Superclass properties "
-"are not allowed and subclass properties do not make sense. In other words, "
-"<literal>INSERT</literal> statements are inherently non-polymorphic."
-msgstr ""
-"properties_list和SQL <literal>INSERT</literal> 语句中的<literal>字段定义"
-"（column speficiation）</literal>类似。对参与继承树映射的实体而言，只有直接定"
-"义在给定的类级别的属性才能直接在 properties_list 中使用。超类的属性不被支持；"
-"子类的属性无意义。换句话说，<literal>INSERT</literal> 天生不支持多态。"
+#, no-c-format
+msgid "The properties_list is analogous to the <literal>column specification</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritance, only properties directly defined on that given class-level can be used in the properties_list. Superclass properties are not allowed and subclass properties do not make sense. In other words, <literal>INSERT</literal> statements are inherently non-polymorphic."
+msgstr "properties_list 和 SQL <literal>INSERT</literal> 语句中的<literal>字段定义（column speficiation）</literal>类似。对参与继承树映射的实体而言，只有直接定义在给定的类级别的属性才能直接在 properties_list 中使用。超类的属性不被支持；子类的属性无意义。换句话说，<literal>INSERT</literal> 天生不支持多态性。"
#. Tag: para
#: batch.xml:247
-#, fuzzy, no-c-format
-msgid ""
-"select_statement can be any valid HQL select query, with the caveat that the "
-"return types must match the types expected by the insert. Currently, this is "
-"checked during query compilation rather than allowing the check to relegate "
-"to the database. This might, however, cause problems between Hibernate "
-"<literal>Type</literal>s which are <emphasis>equivalent</emphasis> as "
-"opposed to <emphasis>equal</emphasis>. This might cause issues with "
-"mismatches between a property defined as a <literal>org.hibernate.type."
-"DateType</literal> and a property defined as a <literal>org.hibernate.type."
-"TimestampType</literal>, even though the database might not make a "
-"distinction or might be able to handle the conversion."
-msgstr ""
-"select_statement 可以是任何合法的 HQL 选择查询，不过要保证返回类型必须和要插"
-"入的类型完全匹配。目前，这一检查是在查询编译的时候进行的，而不是把它交给数据"
-"库。注意，在Hibernate<literal>Type</literal> 间如果只是<emphasis>等价"
-"（equivalent）</emphasis>而非<emphasis>相等（equal）</emphasis>，会导致问题。"
-"定义为 <literal>org.hibernate.type.DateType</literal> 和 <literal>org."
-"hibernate.type.TimestampType</literal> 的两个属性可能会产生类型不匹配错误，虽"
-"然数据库级可能不加区分或者可以处理这种转换。"
+#, no-c-format
+msgid "select_statement can be any valid HQL select query, with the caveat that the return types must match the types expected by the insert. Currently, this is checked during query compilation rather than allowing the check to relegate to the database. This might, however, cause problems between Hibernate <literal>Type</literal>s which are <emphasis>equivalent</emphasis> as opposed to <emphasis>equal</emphasis>. This might cause issues with mismatches between a property defined as a <literal>org.hibernate.type.DateType</literal> and a property defined as a <literal>org.hibernate.type.TimestampType</literal>, even though the database might not make a distinction or might be able to handle the conversion."
+msgstr "select_statement 可以是任何合法的 HQL 选择查询，不过要保证返回类型必须和要插入的类型完全匹配。目前，这一检查是在查询编译的时候进行的，而不是把它交给数据库。注意，在Hibernate<literal>Type</literal> 间如果只是<emphasis>等价（equivalent）</emphasis>而非<emphasis>相等（equal）</emphasis>，会导致问题。定义为 <literal>org.hibernate.type.DateType</literal> 和 <literal>org.hibernate.type.TimestampType</literal> 的两个属性可能会产生类型不匹配错误，虽然数据库级可能不加区分或者可以处理这种转换。 "
#. Tag: para
#: batch.xml:259
-#, fuzzy, no-c-format
-msgid ""
-"For the id property, the insert statement gives you two options. You can "
-"either explicitly specify the id property in the properties_list, in which "
-"case its value is taken from the corresponding select expression, or omit it "
-"from the properties_list, in which case a generated value is used. This "
-"latter option is only available when using id generators that operate in the "
-"database; attempting to use this option with any \"in memory\" type "
-"generators will cause an exception during parsing. For the purposes of this "
-"discussion, in-database generators are considered to be <literal>org."
-"hibernate.id.SequenceGenerator</literal> (and its subclasses) and any "
-"implementers of <literal>org.hibernate.id.PostInsertIdentifierGenerator</"
-"literal>. The most notable exception here is <literal>org.hibernate.id."
-"TableHiLoGenerator</literal>, which cannot be used because it does not "
-"expose a selectable way to get its values."
-msgstr ""
-"对 id 属性来说，insert 语句给你两个选择。你可以明确地在 properties_list 表中"
-"指定 id 属性（这样它的值是从对应的 select 表达式中获得），或者在 "
-"properties_list 中省略它（此时使用生成指）。后一种选择只有当使用在数据库中生"
-"成值的 id 产生器时才能使用；如果是“内存”中计算的类型生成器，在解析时会抛出一"
-"个异常。注意，为了说明这一问题，数据库产生值的生成器是 <literal>org."
-"hibernate.id.SequenceGenerator</literal>（和它的子类），以及任何 "
-"<literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> 接口的实"
-"现。这儿最值得注意的意外是 <literal>org.hibernate.id.TableHiLoGenerator</"
-"literal>，它不能在此使用，因为它没有得到其值的途径。"
+#, no-c-format
+msgid "For the id property, the insert statement gives you two options. You can either explicitly specify the id property in the properties_list, in which case its value is taken from the corresponding select expression, or omit it from the properties_list, in which case a generated value is used. This latter option is only available when using id generators that operate in the database; attempting to use this option with any \"in memory\" type generators will cause an exception during parsing. For the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementers of <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal>. The most notable exception here is <literal>org.hibernate.id.TableHiLoGenerator</literal>, which cannot be used because it does not expose a selectable way to get its values."
+msgstr "对 id 属性来说，insert 语句给你两个选择。你可以明确地在 properties_list 表中指定 id 属性（这样它的值是从对应的 select 表达式中获得），或者在 properties_list 中省略它（此时使用生成指）。后一种选择只有当使用在数据库中生成值的 id 产生器时才能使用；如果是“内存”中计算的类型生成器，在解析时会抛出一个异常。注意，为了说明这一问题，数据库产生值的生成器是 <literal>org.hibernate.id.SequenceGenerator</literal>（和它的子类），以及任何 <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> 接口的实现。这儿最值得注意的意外是 <literal>org.hibernate.id.TableHiLoGenerator</literal>，它不能在此使用，因为它没有得到其值的途径。 "
#. Tag: para
#: batch.xml:274
-#, fuzzy, no-c-format
-msgid ""
-"For properties mapped as either <literal>version</literal> or "
-"<literal>timestamp</literal>, the insert statement gives you two options. "
-"You can either specify the property in the properties_list, in which case "
-"its value is taken from the corresponding select expressions, or omit it "
-"from the properties_list, in which case the <literal>seed value</literal> "
-"defined by the <literal>org.hibernate.type.VersionType</literal> is used."
-msgstr ""
-"对映射为 <literal>version</literal> 或 <literal>timestamp</literal> 的属性来"
-"说，insert 语句也给你两个选择，你可以在 properties_list 表中指定（此时其值从"
-"对应的 select 表达式中获得），或者在properties_list中省略它（此时，使用在 "
-"<literal>org.hibernate.type.VersionType</literal> 中定义的 <literal>seed "
-"value（种子值）</literal>）。"
+#, no-c-format
+msgid "For properties mapped as either <literal>version</literal> or <literal>timestamp</literal>, the insert statement gives you two options. You can either specify the property in the properties_list, in which case its value is taken from the corresponding select expressions, or omit it from the properties_list, in which case the <literal>seed value</literal> defined by the <literal>org.hibernate.type.VersionType</literal> is used."
+msgstr "对映射为 <literal>version</literal> 或 <literal>timestamp</literal> 的属性来说，insert 语句也给你两个选择，你可以在 properties_list 表中指定（此时其值从对应的 select 表达式中获得），或者在 properties_list 中省略它（此时，使用在 <literal>org.hibernate.type.VersionType</literal> 中定义的 <literal>seed value（种子值）</literal>）。"
#. Tag: para
#: batch.xml:284
-#, fuzzy, no-c-format
-msgid ""
-"The following is an example of an HQL <literal>INSERT</literal> statement "
-"execution:"
-msgstr "执行 HQL <literal>INSERT</literal> 语句的例子如下："
+#, no-c-format
+msgid "The following is an example of an HQL <literal>INSERT</literal> statement execution:"
+msgstr "下面是一个执行 HQL <literal>INSERT</literal> 语句的例子："
#. Tag: programlisting
#: batch.xml:288
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
-"String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c."
-"name from Customer c where ...\";\n"
+"String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
"int createdEntities = s.createQuery( hqlInsert )\n"
" .executeUpdate();\n"
"tx.commit();\n"
"session.close();]]>"
msgstr ""
-"Session session = sessionFactory.openSession();\n"
+"<![CDATA[Session session = sessionFactory.openSession();\n"
"Transaction tx = session.beginTransaction();\n"
"\n"
-"String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c."
-"name from Customer \n"
-" c where ...\";\n"
+"String hqlInsert = \"insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...\";\n"
"int createdEntities = s.createQuery( hqlInsert )\n"
" .executeUpdate();\n"
"tx.commit();\n"
-"session.close();"
+"session.close();]]>"
+
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po 2009-11-22 23:50:13 UTC (rev 96688)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/configuration.po 2009-11-22 23:53:28 UTC (rev 96689)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2009-11-11 10:35+1000\n"
+"PO-Revision-Date: 2009-11-23 09:32+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,9 +22,9 @@
#. Tag: para
#: configuration.xml:31
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Hibernate is designed to operate in many different environments and, as such, there is a broad range of configuration parameters. Fortunately, most have sensible default values and Hibernate is distributed with an example <literal>hibernate.properties</literal> file in <literal>etc/</literal> that displays the various options. Simply put the example file in your classpath and customize it to suit your needs."
-msgstr "由于 Hibernate 是为了能在各种不同环境下工作而设计的，因此存在着大量的配置参数。幸运的是多数配置参数都有比较直观的默认值，并有随 Hibernate 一同分发的配置样例 <literal>hibernate.properties</literal>（位于 <literal>etc/</literal>）来展示各种配置选项。所需做的仅仅是将这个样例文件复制到类路径（classpath）下并做一些自定义的修改。"
+msgstr "由于 Hibernate 是为了能在各种不同环境下工作而设计的，因此存在着大量的配置参数。幸运的是多数配置参数都有比较直观的默认值，并有随 Hibernate 一同分发的配置样例 <literal>hibernate.properties</literal>（位于 <literal>etc/</literal>）来展示各种配置选项。所需做的仅仅是将这个样例文件复制到类路径（classpath）下并进行定制。"
#. Tag: title
#: configuration.xml:40
@@ -34,61 +34,61 @@
#. Tag: para
#: configuration.xml:42
-#, fuzzy, no-c-format
+#, no-c-format
msgid "An instance of <classname>org.hibernate.cfg.Configuration</classname> represents an entire set of mappings of an application's Java types to an SQL database. The <classname>org.hibernate.cfg.Configuration</classname> is used to build an immutable <interfacename>org.hibernate.SessionFactory</interfacename>. The mappings are compiled from various XML mapping files."
-msgstr "<literal>org.hibernate.cfg.Configuration</literal> 实例代表了一个应用程序中 Java 类型到SQL数据库映射的完整集合。<literal>Configuration</literal> 被用来构建一个（不可变的（immutable））<literal>SessionFactory</literal>。映射定义则由不同的 XML 映射定义文件编译而来。"
+msgstr "<literal>org.hibernate.cfg.Configuration</literal> 实例代表了一个应用程序中 Java 类型到SQL数据库映射的完整集合。<classname>org.hibernate.cfg.Configuration</classname> 被用来构建一个（不可变的（immutable））<interfacename>org.hibernate.SessionFactory</interfacename>。映射定义则由不同的 XML 映射定义文件编译而来。"
#. Tag: para
#: configuration.xml:49
-#, fuzzy, no-c-format
+#, no-c-format
msgid "You can obtain a <classname>org.hibernate.cfg.Configuration</classname> instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use <literal>addResource()</literal>. For example:"
-msgstr "你可以直接实例化 <literal>Configuration</literal> 来获取一个实例，并为它指定 XML 映射定义文件。如果映射定义文件在类路径（classpath）中，请使用 <literal>addResource（)</literal>："
+msgstr "你可以直接实例化 <classname>org.hibernate.cfg.Configuration</classname> 来获取一个实例，并为它指定 XML 映射定义文件。如果映射定义文件在类路径（classpath）中，请使用 <literal>addResource（)</literal>。例如："
#. Tag: programlisting
#: configuration.xml:55
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Configuration cfg = new Configuration()\n"
" .addResource(\"Item.hbm.xml\")\n"
" .addResource(\"Bid.hbm.xml\");]]>"
msgstr ""
-"Configuration cfg = new Configuration()\n"
+"<![CDATA[Configuration cfg = new Configuration()\n"
" .addResource(\"Item.hbm.xml\")\n"
-" .addResource(\"Bid.hbm.xml\");"
+" .addResource(\"Bid.hbm.xml\");]]>"
#. Tag: para
#: configuration.xml:57
-#, fuzzy, no-c-format
+#, no-c-format
msgid "An alternative way is to specify the mapped class and allow Hibernate to find the mapping document for you:"
-msgstr "一个替代方法（有时是更好的选择）是，指定被映射的类，让 Hibernate 帮你寻找映射定义文件："
+msgstr "一个替代方法（有时是更好的选择）是，指定被映射的类，让 Hibernate 帮你寻找映射定义文件： "
#. Tag: programlisting
#: configuration.xml:62
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Configuration cfg = new Configuration()\n"
" .addClass(org.hibernate.auction.Item.class)\n"
" .addClass(org.hibernate.auction.Bid.class);]]>"
msgstr ""
-"Configuration cfg = new Configuration()\n"
+"<![CDATA[Configuration cfg = new Configuration()\n"
" .addClass(org.hibernate.auction.Item.class)\n"
-" .addClass(org.hibernate.auction.Bid.class);"
+" .addClass(org.hibernate.auction.Bid.class);]]>"
#. Tag: para
#: configuration.xml:64
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Hibernate will then search for mapping files named <filename>/org/hibernate/auction/Item.hbm.xml</filename> and <filename>/org/hibernate/auction/Bid.hbm.xml</filename> in the classpath. This approach eliminates any hardcoded filenames."
-msgstr "Hibernate 将会在类路径（classpath）中寻找名字为 <literal>/org/hibernate/auction/Item.hbm.xml</literal> 和 <literal>/org/hibernate/auction/Bid.hbm.xml</literal> 映射定义文件。这种方式消除了任何对文件名的硬编码（hardcoded）。"
+msgstr "Hibernate 将会在类路径（classpath）中寻找名字为 <filename>/org/hibernate/auction/Item.hbm.xml</filename> 和 <filename>/org/hibernate/auction/Bid.hbm.xml</filename> 映射定义文件。这种方式消除了任何对文件名的硬编码（hardcoded）。"
#. Tag: para
#: configuration.xml:70
-#, fuzzy, no-c-format
+#, no-c-format
msgid "A <classname>org.hibernate.cfg.Configuration</classname> also allows you to specify configuration properties. For example:"
-msgstr "<literal>Configuration</literal> 也允许你指定配置属性："
+msgstr "<classname>org.hibernate.cfg.Configuration</classname>> 也允许你指定配置属性。例如："
#. Tag: programlisting
#: configuration.xml:75
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Configuration cfg = new Configuration()\n"
" .addClass(org.hibernate.auction.Item.class)\n"
@@ -97,30 +97,30 @@
" .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
" .setProperty(\"hibernate.order_updates\", \"true\");]]>"
msgstr ""
-"Configuration cfg = new Configuration()\n"
+"<![CDATA[Configuration cfg = new Configuration()\n"
" .addClass(org.hibernate.auction.Item.class)\n"
" .addClass(org.hibernate.auction.Bid.class)\n"
" .setProperty(\"hibernate.dialect\", \"org.hibernate.dialect.MySQLInnoDBDialect\")\n"
" .setProperty(\"hibernate.connection.datasource\", \"java:comp/env/jdbc/test\")\n"
-" .setProperty(\"hibernate.order_updates\", \"true\");"
+" .setProperty(\"hibernate.order_updates\", \"true\");]]>"
#. Tag: para
#: configuration.xml:77
-#, fuzzy, no-c-format
+#, no-c-format
msgid "This is not the only way to pass configuration properties to Hibernate. Some alternative options include:"
-msgstr "当然这不是唯一的传递 Hibernate 配置属性的方式，其他可选方式还包括："
+msgstr "当然这不是唯一的传递 Hibernate 配置属性的方式，其他可选方式还包括： "
#. Tag: para
#: configuration.xml:84
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Pass an instance of <classname>java.util.Properties</classname> to <literal>Configuration.setProperties()</literal>."
-msgstr "传一个 <literal>java.util.Properties</literal> 实例给 <literal>Configuration.setProperties()</literal>。"
+msgstr "传一个 <classname>java.util.Properties</classname> 实例给 <literal>Configuration.setProperties()</literal>。"
#. Tag: para
#: configuration.xml:90
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Place a file named <filename>hibernate.properties</filename> in a root directory of the classpath."
-msgstr "将 <literal>hibernate.properties</literal> 放置在类路径（classpath）的根目录下 （root directory）。"
+msgstr "将 <filename>hibernate.properties</filename> 放置在类路径（classpath）的根目录下（root directory）。"
#. Tag: para
#: configuration.xml:95
@@ -130,9 +130,9 @@
#. Tag: para
#: configuration.xml:100
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Include <literal><property></literal> elements in <literal>hibernate.cfg.xml</literal> (this is discussed later)."
-msgstr "在 <literal>hibernate.cfg.xml</literal> 中加入元素 <literal><property></literal>（稍后讨论）。"
+msgstr "在 <literal>hibernate.cfg.xml</literal> 中加入元素 <literal><property></literal>（稍后讨论）。 "
#. Tag: para
#: configuration.xml:107
@@ -142,9 +142,9 @@
#. Tag: para
#: configuration.xml:111
-#, fuzzy, no-c-format
+#, no-c-format
msgid "The <classname>org.hibernate.cfg.Configuration</classname> is intended as a startup-time object that will be discarded once a <literal>SessionFactory</literal> is created."
-msgstr "<literal>Configuration</literal> 实例被设计成启动期间（startup-time）对象，一旦 <literal>SessionFactory</literal> 创建完成它就被丢弃了。"
+msgstr "<classname>org.hibernate.cfg.Configuration</classname> 实例被设计成启动期间（startup-time）对象，一旦 <literal>SessionFactory</literal> 创建完成它就被丢弃了。"
#. Tag: title
#: configuration.xml:119
Modified: projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/events.po
===================================================================
--- projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/events.po 2009-11-22 23:50:13 UTC (rev 96688)
+++ projects/docs/enterprise/5.0/Hibernate/Hibernate_Core/zh-CN/events.po 2009-11-22 23:53:28 UTC (rev 96689)
@@ -6,7 +6,7 @@
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2009-09-15 07:03+0000\n"
-"PO-Revision-Date: 2007-02-26 10:59+1000\n"
+"PO-Revision-Date: 2009-11-23 09:36+1000\n"
"Last-Translator: Xi HUANG <xhuang at redhat.com>\n"
"Language-Team: <en at li.org>\n"
"MIME-Version: 1.0\n"
@@ -22,14 +22,9 @@
#. Tag: para
#: events.xml:31
-#, fuzzy, no-c-format
-msgid ""
-"It is useful for the application to react to certain events that occur "
-"inside Hibernate. This allows for the implementation of generic "
-"functionality and the extension of Hibernate functionality."
-msgstr ""
-"应用程序能够响应 Hibernate 内部产生的特定事件是非常有用的。这样就允许实现某些"
-"通用的功能 以及允许对 Hibernate 功能进行扩展。"
+#, no-c-format
+msgid "It is useful for the application to react to certain events that occur inside Hibernate. This allows for the implementation of generic functionality and the extension of Hibernate functionality."
+msgstr "应用程序能够响应 Hibernate 内部产生的特定事件是非常有用的。这样就允许实现某些通用的功能以及允许对 Hibernate 功能进行扩展。"
#. Tag: title
#: events.xml:38
@@ -39,40 +34,19 @@
#. Tag: para
#: events.xml:40
-#, fuzzy, no-c-format
-msgid ""
-"The <literal>Interceptor</literal> interface provides callbacks from the "
-"session to the application, allowing the application to inspect and/or "
-"manipulate properties of a persistent object before it is saved, updated, "
-"deleted or loaded. One possible use for this is to track auditing "
-"information. For example, the following <literal>Interceptor</literal> "
-"automatically sets the <literal>createTimestamp</literal> when an "
-"<literal>Auditable</literal> is created and updates the "
-"<literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</"
-"literal> is updated."
-msgstr ""
-"<literal>Interceptor</literal> 接口提供了从会话（session）回调（callback）应"
-"用程序（application）的机制， 这种回调机制可以允许应用程序在持久化对象被保"
-"存、更新、删除或是加载之前，检查并（或）修改其 属性。一个可能的用途，就是用来"
-"跟踪审核（auditing）信息。例如：下面的这个<literal>拦截器</literal>，会在一个"
-"实现了 <literal>Auditable</literal> 接口的对象被创建时自动地设置 "
-"<literal>createTimestamp</literal> 属性，并在实现了 <literal>Auditable</"
-"literal> 接口的对象被更新时，同步更新 <literal>lastUpdateTimestamp</literal> "
-"属性。"
+#, no-c-format
+msgid "The <literal>Interceptor</literal> interface provides callbacks from the session to the application, allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded. One possible use for this is to track auditing information. For example, the following <literal>Interceptor</literal> automatically sets the <literal>createTimestamp</literal> when an <literal>Auditable</literal> is created and updates the <literal>lastUpdateTimestamp</literal> property when an <literal>Auditable</literal> is updated."
+msgstr "<literal>Interceptor</literal> 接口提供了从会话（session）回调（callback）应用程序（application）的机制， 这种回调机制可以允许应用程序在持久化对象被保存、更新、删除或是加载之前，检查并（或）修改其 属性。一个可能的用途，就是用来跟踪审核（auditing）信息。例如：下面的这个<literal>拦截器</literal>，会在一个实现了 <literal>Auditable</literal> 接口的对象被创建时自动地设置 <literal>createTimestamp</literal> 属性，并在实现了 <literal>Auditable</literal> 接口的对象被更新时，同步更新 <literal>lastUpdateTimestamp</literal> 属性。 "
#. Tag: para
#: events.xml:51
-#, fuzzy, no-c-format
-msgid ""
-"You can either implement <literal>Interceptor</literal> directly or extend "
-"<literal>EmptyInterceptor</literal>."
-msgstr ""
-"你可以直接实现 <literal>Interceptor</literal> 接口，也可以（最好）继承自 "
-"<literal>EmptyInterceptor</literal>。"
+#, no-c-format
+msgid "You can either implement <literal>Interceptor</literal> directly or extend <literal>EmptyInterceptor</literal>."
+msgstr "你可以直接实现 <literal>Interceptor</literal> 接口，也可以（最好）继承自 <literal>EmptyInterceptor</literal>。 "
#. Tag: programlisting
#: events.xml:56
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[package org.hibernate.test;\n"
"\n"
@@ -148,8 +122,7 @@
"\n"
" public void afterTransactionCompletion(Transaction tx) {\n"
" if ( tx.wasCommitted() ) {\n"
-" System.out.println(\"Creations: \" + creates + \", Updates: \" + "
-"updates, \"Loads: \" + loads);\n"
+" System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
" }\n"
" updates=0;\n"
" creates=0;\n"
@@ -158,7 +131,7 @@
"\n"
"}]]>"
msgstr ""
-"package org.hibernate.test;\n"
+"<![CDATA[package org.hibernate.test;\n"
"\n"
"import java.io.Serializable;\n"
"import java.util.Date;\n"
@@ -191,7 +164,7 @@
"\n"
" if ( entity instanceof Auditable ) {\n"
" updates++;\n"
-" for ( int i=0; i < propertyNames.length; i++ ) {\n"
+" for ( int i=0; i < propertyNames.length; i++ ) {\n"
" if ( \"lastUpdateTimestamp\".equals( propertyNames[i] ) ) {\n"
" currentState[i] = new Date();\n"
" return true;\n"
@@ -220,7 +193,7 @@
"\n"
" if ( entity instanceof Auditable ) {\n"
" creates++;\n"
-" for ( int i=0; i<propertyNames.length; i++ ) {\n"
+" for ( int i=0; i<propertyNames.length; i++ ) {\n"
" if ( \"createTimestamp\".equals( propertyNames[i] ) ) {\n"
" state[i] = new Date();\n"
" return true;\n"
@@ -232,72 +205,44 @@
"\n"
" public void afterTransactionCompletion(Transaction tx) {\n"
" if ( tx.wasCommitted() ) {\n"
-" System.out.println(\"Creations: \" + creates + \", Updates: \" + "
-"updates,\n"
-" \"Loads: \" + loads);\n"
+" System.out.println(\"Creations: \" + creates + \", Updates: \" + updates, \"Loads: \" + loads);\n"
" }\n"
" updates=0;\n"
" creates=0;\n"
" loads=0;\n"
" }\n"
"\n"
-"}"
+"}]]>"
#. Tag: para
#: events.xml:58
-#, fuzzy, no-c-format
-msgid ""
-"There are two kinds of inteceptors: <literal>Session</literal>-scoped and "
-"<literal>SessionFactory</literal>-scoped."
-msgstr ""
-"拦截器可以有两种：<literal>Session</literal> 范围内的，和 "
-"<literal>SessionFactory</literal> 范围内的。"
+#, no-c-format
+msgid "There are two kinds of inteceptors: <literal>Session</literal>-scoped and <literal>SessionFactory</literal>-scoped."
+msgstr "拦截器可以有两种：<literal>Session</literal> 范围内的和 <literal>SessionFactory</literal> 范围内的。"
#. Tag: para
#: events.xml:63
#, no-c-format
-msgid ""
-"A <literal>Session</literal>-scoped interceptor is specified when a session "
-"is opened using one of the overloaded SessionFactory.openSession() methods "
-"accepting an <literal>Interceptor</literal>."
-msgstr ""
-"当使用某个重载的 SessionFactory.openSession() 使用 <literal>Interceptor</"
-"literal> 作为参数调用打开一个 session 的时候，就指定了 <literal>Session</"
-"literal> 范围内的拦截器。"
+msgid "A <literal>Session</literal>-scoped interceptor is specified when a session is opened using one of the overloaded SessionFactory.openSession() methods accepting an <literal>Interceptor</literal>."
+msgstr "当使用某个重载的 SessionFactory.openSession() 使用 <literal>Interceptor</literal> 作为参数调用打开一个 session 的时候，就指定了 <literal>Session</literal> 范围内的拦截器。"
#. Tag: programlisting
#: events.xml:69
-#, fuzzy, no-c-format
+#, no-c-format
msgid "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
-msgstr "Session session = sf.openSession( new AuditInterceptor() );"
+msgstr "<![CDATA[Session session = sf.openSession( new AuditInterceptor() );]]>"
#. Tag: para
#: events.xml:71
-#, fuzzy, no-c-format
-msgid ""
-"A <literal>SessionFactory</literal>-scoped interceptor is registered with "
-"the <literal>Configuration</literal> object prior to building the "
-"<literal>SessionFactory</literal>. Unless a session is opened explicitly "
-"specifying the interceptor to use, the supplied interceptor will be applied "
-"to all sessions opened from that <literal>SessionFactory</literal>. "
-"<literal>SessionFactory</literal>-scoped interceptors must be thread safe. "
-"Ensure that you do not store session-specific states, since multiple "
-"sessions will use this interceptor potentially concurrently."
-msgstr ""
-"<literal>SessionFactory</literal> 范围内的拦截器要通过 "
-"<literal>Configuration</literal> 中注册，而这必须在创建 "
-"<literal>SessionFactory</literal> 之前。在这种情况下，给出的拦截器会被这个 "
-"<literal>SessionFactory</literal> 所打开的所有 session 使用了；除非 session "
-"打开时明确指明了使用的拦截器。<literal>SessionFactory</literal> 范围内的拦截"
-"器，必须是线程安全的，因为多个 session 可能并发使用这个拦截器，要因此小心不要"
-"保存与 session 相关的状态。"
+#, no-c-format
+msgid "A <literal>SessionFactory</literal>-scoped interceptor is registered with the <literal>Configuration</literal> object prior to building the <literal>SessionFactory</literal>. Unless a session is opened explicitly specifying the interceptor to use, the supplied interceptor will be applied to all sessions opened from that <literal>SessionFactory</literal>. <literal>SessionFactory</literal>-scoped interceptors must be thread safe. Ensure that you do not store session-specific states, since multiple sessions will use this interceptor potentially concurrently."
+msgstr "<literal>SessionFactory</literal> 范围内的拦截器要通过 <literal>Configuration</literal> 中注册，而这必须在创建 <literal>SessionFactory</literal> 之前。在这种情况下，给出的拦截器会被这个 <literal>SessionFactory</literal> 所打开的所有 session 使用了；除非 session 打开时明确指明了使用的拦截器。<literal>SessionFactory</literal> 范围内的拦截器，必须是线程安全的。确保你没有保存 session 专有的状态，因为多个 session 可能并发使用这个拦截器。"
#. Tag: programlisting
#: events.xml:80
-#, fuzzy, no-c-format
-msgid ""
-"<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
-msgstr "new Configuration().setInterceptor( new AuditInterceptor() );"
+#, no-c-format
+msgid "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
+msgstr "<![CDATA[new Configuration().setInterceptor( new AuditInterceptor() );]]>"
#. Tag: title
#: events.xml:85
@@ -307,187 +252,111 @@
#. Tag: para
#: events.xml:87
-#, fuzzy, no-c-format
-msgid ""
-"If you have to react to particular events in your persistence layer, you can "
-"also use the Hibernate3 <emphasis>event</emphasis> architecture. The event "
-"system can be used in addition, or as a replacement, for interceptors."
-msgstr ""
-"如果需要响应持久层的某些特殊事件，你也可以使用 Hibernate3 的事件框架。 该事件"
-"系统可以用来替代拦截器，也可以作为拦截器的补充来使用。"
+#, no-c-format
+msgid "If you have to react to particular events in your persistence layer, you can also use the Hibernate3 <emphasis>event</emphasis> architecture. The event system can be used in addition, or as a replacement, for interceptors."
+msgstr "如果需要响应持久层的某些特殊事件，你也可以使用 Hibernate3 的事件框架。该事件系统可以用来替代拦截器，也可以作为拦截器的补充来使用。 "
#. Tag: para
#: events.xml:93
-#, fuzzy, no-c-format
-msgid ""
-"All the methods of the <literal>Session</literal> interface correlate to an "
-"event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</"
-"literal>, etc. Consult the XML configuration-file DTD or the <literal>org."
-"hibernate.event</literal> package for the full list of defined event types. "
-"When a request is made of one of these methods, the Hibernate "
-"<literal>Session</literal> generates an appropriate event and passes it to "
-"the configured event listeners for that type. Out-of-the-box, these "
-"listeners implement the same processing in which those methods always "
-"resulted. However, you are free to implement a customization of one of the "
-"listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by "
-"the registered implementation of the <literal>LoadEventListener</literal> "
-"interface), in which case their implementation would be responsible for "
-"processing any <literal>load()</literal> requests made of the "
-"<literal>Session</literal>."
-msgstr ""
-"基本上，<literal>Session</literal> 接口的每个方法都有相对应的事件。比如 "
-"<literal>LoadEvent</literal>，<literal>FlushEvent</literal>，等等（查阅 XML "
-"配置文件的 DTD，以及 <literal>org.hibernate.event</literal> 包来获得所有已定"
-"义的事件的列表）。当某个方 法被调用时，Hibernate <literal>Session</literal>会"
-"生成一个相对应的事件并激活所 有配置好的事件监听器。系统预设的监听器实现的处理"
-"过程就是被监听的方法要做的（被监听的方法所做的其实仅仅是激活监听器， “实际”的"
-"工作是由监听器完成的）。不过，你可以自由地选择实现 一个自己定制的监听器（比"
-"如，实现并注册用来处理处理 <literal>LoadEvent</literal> 的 "
-"<literal>LoadEventListener</literal> 接口）， 来负责处理所有的调用 "
-"<literal>Session</literal> 的 <literal>load()</literal> 方法的请求。"
+#, no-c-format
+msgid "All the methods of the <literal>Session</literal> interface correlate to an event. You have a <literal>LoadEvent</literal>, a <literal>FlushEvent</literal>, etc. Consult the XML configuration-file DTD or the <literal>org.hibernate.event</literal> package for the full list of defined event types. When a request is made of one of these methods, the Hibernate <literal>Session</literal> generates an appropriate event and passes it to the configured event listeners for that type. Out-of-the-box, these listeners implement the same processing in which those methods always resulted. However, you are free to implement a customization of one of the listener interfaces (i.e., the <literal>LoadEvent</literal> is processed by the registered implementation of the <literal>LoadEventListener</literal> interface), in which case their implementation would be responsible for processing any <literal>load()</literal> requests made of the <literal>Session</literal>."
+msgstr "基本上，<literal>Session</literal> 接口的每个方法都有相对应的事件。比如 <literal>LoadEvent</literal>，<literal>FlushEvent</literal>，等等（查阅 XML 配置文件的 DTD，以及 <literal>org.hibernate.event</literal> 包来获得所有已定义的事件的列表）。当某个方 法被调用时，Hibernate <literal>Session</literal>会生成一个相对应的事件并激活所 有配置好的事件监听器。系统预设的监听器实现的处理过程就是被监听的方法要做的（被监听的方法所做的其实仅仅是激活监听器，“实际”的工作是由监听器完成的）。不过，你可以自由地选择实现 一个自己定制的监听器（比如，实现并注册用来处理处理 <literal>LoadEvent</literal> 的 <literal>LoadEventListener</literal> 接口）， 来负责处理所有的调用 <literal>Session</literal> 的 <literal>load()</literal> 方法的请求。"
#. Tag: para
#: events.xml:108
-#, fuzzy, no-c-format
-msgid ""
-"The listeners should be considered singletons. This means they are shared "
-"between requests, and should not save any state as instance variables."
-msgstr ""
-"监听器应该被看作是单例（singleton）对象，也就是说，所有同类型的事件的处理共享"
-"同一个监听器实例，因此监听器 不应该保存任何状态（也就是不应该使用成员变量）。"
+#, no-c-format
+msgid "The listeners should be considered singletons. This means they are shared between requests, and should not save any state as instance variables."
+msgstr "监听器应该被看作是单例（singleton）对象，也就是说，所有同类型的事件的处理共享同一个监听器实例，因此监听器不应该保存任何状态（也就是不应该使用成员变量）。"
#. Tag: para
#: events.xml:113
-#, fuzzy, no-c-format
-msgid ""
-"A custom listener implements the appropriate interface for the event it "
-"wants to process and/or extend one of the convenience base classes (or even "
-"the default event listeners used by Hibernate out-of-the-box as these are "
-"declared non-final for this purpose). Custom listeners can either be "
-"registered programmatically through the <literal>Configuration</literal> "
-"object, or specified in the Hibernate configuration XML. Declarative "
-"configuration through the properties file is not supported. Here is an "
-"example of a custom load event listener:"
-msgstr ""
-"用户定制的监听器应该实现与所要处理的事件相对应的接口，或者从一个合适的基类继"
-"承（甚至是从 Hibernate 自带的默认事件监听器类继承，为了方便你这样做，这些类都"
-"被声明成 non-final 的了）。用户定制的监听器可以通过编程使用 "
-"<literal>Configuration</literal> 对象 来注册，也可以在Hibernate的 XML 格式的"
-"配置文件中进行声明（不支持在 Properties 格式的配置文件声明监听器）。 下面是一"
-"个用户定制的加载事件（load event）的监听器："
+#, no-c-format
+msgid "A custom listener implements the appropriate interface for the event it wants to process and/or extend one of the convenience base classes (or even the default event listeners used by Hibernate out-of-the-box as these are declared non-final for this purpose). Custom listeners can either be registered programmatically through the <literal>Configuration</literal> object, or specified in the Hibernate configuration XML. Declarative configuration through the properties file is not supported. Here is an example of a custom load event listener:"
+msgstr "用户定制的监听器应该实现与所要处理的事件相对应的接口，或者从一个合适的基类继承（甚至是从 Hibernate 自带的默认事件监听器类继承，为了方便你这样做，这些类都被声明成 non-final 的了）。用户定制的监听器可以通过编程使用 <literal>Configuration</literal> 对象 来注册，也可以在Hibernate的 XML 格式的配置文件中进行声明（不支持在 Properties 格式的配置文件声明监听器）。下面是一个用户定制的加载事件（load event）的监听器："
#. Tag: programlisting
#: events.xml:123
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
" // this is the single method defined by the LoadEventListener interface\n"
-" public void onLoad(LoadEvent event, LoadEventListener.LoadType "
-"loadType)\n"
+" public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
" throws HibernateException {\n"
-" if ( !MySecurity.isAuthorized( event.getEntityClassName(), event."
-"getEntityId() ) ) {\n"
+" if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
" throw MySecurityException(\"Unauthorized access\");\n"
" }\n"
" }\n"
"}]]>"
msgstr ""
-"public class MyLoadListener implements LoadEventListener {\n"
+"<![CDATA[public class MyLoadListener implements LoadEventListener {\n"
" // this is the single method defined by the LoadEventListener interface\n"
-" public void onLoad(LoadEvent event, LoadEventListener.LoadType "
-"loadType)\n"
+" public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType)\n"
" throws HibernateException {\n"
-" if ( !MySecurity.isAuthorized( event.getEntityClassName(), event."
-"getEntityId() ) ) {\n"
+" if ( !MySecurity.isAuthorized( event.getEntityClassName(), event.getEntityId() ) ) {\n"
" throw MySecurityException(\"Unauthorized access\");\n"
" }\n"
" }\n"
-"}"
+"}]]>"
#. Tag: para
#: events.xml:125
#, no-c-format
-msgid ""
-"You also need a configuration entry telling Hibernate to use the listener in "
-"addition to the default listener:"
-msgstr ""
-"你还需要修改一处配置，来告诉 Hibernate，除了默认的监听器，还要附加选定的监听"
-"器。"
+msgid "You also need a configuration entry telling Hibernate to use the listener in addition to the default listener:"
+msgstr "你还需要修改一处配置，来告诉 Hibernate，除了默认的监听器，还要附加选定的监听器。"
#. Tag: programlisting
#: events.xml:130
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[<hibernate-configuration>\n"
" <session-factory>\n"
" ...\n"
" <event type=\"load\">\n"
" <listener class=\"com.eg.MyLoadListener\"/>\n"
-" <listener class=\"org.hibernate.event.def."
-"DefaultLoadEventListener\"/>\n"
+" <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
" </event>\n"
" </session-factory>\n"
"</hibernate-configuration>]]>"
msgstr ""
-"<hibernate-configuration>\n"
-" <session-factory>\n"
+"<![CDATA[<hibernate-configuration>\n"
+" <session-factory>\n"
" ...\n"
-" <event type=\"load\">\n"
-" <listener class=\"com.eg.MyLoadListener\"/>\n"
-" <listener class=\"org.hibernate.event.def."
-"DefaultLoadEventListener\"/>\n"
-" </event>\n"
-" </session-factory>\n"
-"</hibernate-configuration>"
+" <event type=\"load\">\n"
+" <listener class=\"com.eg.MyLoadListener\"/>\n"
+" <listener class=\"org.hibernate.event.def.DefaultLoadEventListener\"/>\n"
+" </event>\n"
+" </session-factory>\n"
+"</hibernate-configuration>]]>"
#. Tag: para
#: events.xml:132
-#, fuzzy, no-c-format
+#, no-c-format
msgid "Instead, you can register it programmatically:"
-msgstr "看看用另一种方式，通过编程的方式来注册它。"
+msgstr "或者，你可以通过编程的方式来注册它："
#. Tag: programlisting
#: events.xml:136
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
"<![CDATA[Configuration cfg = new Configuration();\n"
-"LoadEventListener[] stack = { new MyLoadListener(), new "
-"DefaultLoadEventListener() };\n"
+"LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
"cfg.EventListeners().setLoadEventListeners(stack);]]>"
msgstr ""
-"Configuration cfg = new Configuration();\n"
-"LoadEventListener[] stack = { new MyLoadListener(), new "
-"DefaultLoadEventListener() };\n"
-"cfg.EventListeners().setLoadEventListeners(stack);"
+"<![CDATA[Configuration cfg = new Configuration();\n"
+"LoadEventListener[] stack = { new MyLoadListener(), new DefaultLoadEventListener() };\n"
+"cfg.EventListeners().setLoadEventListeners(stack);]]>"
#. Tag: para
#: events.xml:138
-#, fuzzy, no-c-format
-msgid ""
-"Listeners registered declaratively cannot share instances. If the same class "
-"name is used in multiple <literal><listener/></literal> elements, each "
-"reference will result in a separate instance of that class. If you need to "
-"share listener instances between listener types you must use the "
-"programmatic registration approach."
-msgstr ""
-"通过在XML配置文件声明而注册的监听器不能共享实例。如果在多个 <literal><"
-"listener/></literal> 节点中使用 了相同的类的名字，则每一个引用都将会产生一"
-"个独立的实例。如果你需要在多个监听器类型之间共享 监听器的实例，则你必须使用编"
-"程的方式来进行注册。"
+#, no-c-format
+msgid "Listeners registered declaratively cannot share instances. If the same class name is used in multiple <literal><listener/></literal> elements, each reference will result in a separate instance of that class. If you need to share listener instances between listener types you must use the programmatic registration approach."
+msgstr "通过在XML配置文件声明而注册的监听器不能共享实例。如果在多个 <literal><listener/></literal> 节点中使用 了相同的类的名字，则每一个引用都将会产生一个独立的实例。如果你需要在多个监听器类型之间共享 监听器的实例，则你必须使用编程的方式来进行注册。 "
#. Tag: para
#: events.xml:146
-#, fuzzy, no-c-format
-msgid ""
-"Why implement an interface and define the specific type during "
-"configuration? A listener implementation could implement multiple event "
-"listener interfaces. Having the type additionally defined during "
-"registration makes it easier to turn custom listeners on or off during "
-"configuration."
-msgstr ""
-"为什么我们实现了特定监听器的接口，在注册的时候还要明确指出我们要注册哪个事件"
-"的监听器呢？ 这是因为一个类可能实现多个监听器的接口。在注册的时候明确指定要监"
-"听的事件，可以让启用或者禁用对某个事件的监听的配置工作简单些。"
+#, no-c-format
+msgid "Why implement an interface and define the specific type during configuration? A listener implementation could implement multiple event listener interfaces. Having the type additionally defined during registration makes it easier to turn custom listeners on or off during configuration."
+msgstr "为什么我们实现了特定监听器的接口，在注册的时候还要明确指出我们要注册哪个事件的监听器呢？ 这是因为一个类可能实现多个监听器的接口。在注册的时候明确指定要监听的事件，可以让启用或者禁用对某个事件的监听的配置工作简单些。 "
#. Tag: title
#: events.xml:156
@@ -497,86 +366,55 @@
#. Tag: para
#: events.xml:157
-#, fuzzy, no-c-format
-msgid ""
-"Usually, declarative security in Hibernate applications is managed in a "
-"session facade layer. Hibernate3 allows certain actions to be permissioned "
-"via JACC, and authorized via JAAS. This is an optional functionality that is "
-"built on top of the event architecture."
-msgstr ""
-"通常，Hibernate 应用程序的声明式安全机制由会话外观层（session facade）所管"
-"理。现在，Hibernate3允许某些特定的行为由 JACC 进行许可管理，由 JAAS 进行授权"
-"管理。本功能是一个建立在事件框架之上的可选的功能。"
+#, no-c-format
+msgid "Usually, declarative security in Hibernate applications is managed in a session facade layer. Hibernate3 allows certain actions to be permissioned via JACC, and authorized via JAAS. This is an optional functionality that is built on top of the event architecture."
+msgstr "通常，Hibernate 应用程序的声明式安全机制由会话外观层（session facade）所管理。现在，Hibernate3允许某些特定的行为由 JACC 进行许可管理，由 JAAS 进行授权管理。本功能是一个建立在事件框架之上的可选的功能。 "
#. Tag: para
#: events.xml:163
#, no-c-format
-msgid ""
-"First, you must configure the appropriate event listeners, to enable the use "
-"of JAAS authorization."
-msgstr ""
-"首先，你必须要配置适当的事件监听器（event listener），来激活使用 JAAS 管理授"
-"权的功能。"
+msgid "First, you must configure the appropriate event listeners, to enable the use of JAAS authorization."
+msgstr "首先，你必须要配置适当的事件监听器（event listener），来激活使用 JAAS 管理授权的功能。"
#. Tag: programlisting
#: events.xml:168
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
-"<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure."
-"JACCPreDeleteEventListener\"/>\n"
-"<listener type=\"pre-update\" class=\"org.hibernate.secure."
-"JACCPreUpdateEventListener\"/>\n"
-"<listener type=\"pre-insert\" class=\"org.hibernate.secure."
-"JACCPreInsertEventListener\"/>\n"
-"<listener type=\"pre-load\" class=\"org.hibernate.secure."
-"JACCPreLoadEventListener\"/>]]>"
+"<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+"<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+"<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+"<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
msgstr ""
-"<listener type=\"pre-delete\" class=\"org.hibernate.secure."
-"JACCPreDeleteEventListener\"/>\n"
-"<listener type=\"pre-update\" class=\"org.hibernate.secure."
-"JACCPreUpdateEventListener\"/>\n"
-"<listener type=\"pre-insert\" class=\"org.hibernate.secure."
-"JACCPreInsertEventListener\"/>\n"
-"<listener type=\"pre-load\" class=\"org.hibernate.secure."
-"JACCPreLoadEventListener\"/>"
+"<![CDATA[<listener type=\"pre-delete\" class=\"org.hibernate.secure.JACCPreDeleteEventListener\"/>\n"
+"<listener type=\"pre-update\" class=\"org.hibernate.secure.JACCPreUpdateEventListener\"/>\n"
+"<listener type=\"pre-insert\" class=\"org.hibernate.secure.JACCPreInsertEventListener\"/>\n"
+"<listener type=\"pre-load\" class=\"org.hibernate.secure.JACCPreLoadEventListener\"/>]]>"
#. Tag: para
#: events.xml:170
-#, fuzzy, no-c-format
-msgid ""
-"Note that <literal><listener type=\"...\" class=\"...\"/></literal> is "
-"shorthand for <literal><event type=\"...\"><listener class=\"...\"/"
-"></event></literal> when there is exactly one listener for a "
-"particular event type."
-msgstr ""
-"注意，<literal><listener type=\"...\" class=\"...\"/></literal> 只是 "
-"<literal><event type=\"...\"><listener class=\"...\"/></"
-"event></literal> 的简写，对每一个事件类型都必须严格的有一个监听器与之对"
-"应。"
+#, no-c-format
+msgid "Note that <literal><listener type=\"...\" class=\"...\"/></literal> is shorthand for <literal><event type=\"...\"><listener class=\"...\"/></event></literal> when there is exactly one listener for a particular event type."
+msgstr "注意，<literal><listener type=\"...\" class=\"...\"/></literal> 只是 <literal><event type=\"...\"><listener class=\"...\"/></event></literal> 的简写，对每一个事件类型都必须严格的有一个监听器与之对应。 "
#. Tag: para
#: events.xml:176
-#, fuzzy, no-c-format
-msgid ""
-"Next, while still in <literal>hibernate.cfg.xml</literal>, bind the "
-"permissions to roles:"
-msgstr ""
-"接下来，仍然在 <literal>hibernate.cfg.xml</literal> 文件中，绑定角色的权限："
+#, no-c-format
+msgid "Next, while still in <literal>hibernate.cfg.xml</literal>, bind the permissions to roles:"
+msgstr "接下来，仍然在 <literal>hibernate.cfg.xml</literal> 文件中，绑定角色的权限： "
#. Tag: programlisting
#: events.xml:180
-#, fuzzy, no-c-format
+#, no-c-format
msgid ""
-"<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,"
-"read\"/>\n"
+"<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
"<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
msgstr ""
-"<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/"
-">\n"
-"<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>"
+"<![CDATA[<grant role=\"admin\" entity-name=\"User\" actions=\"insert,update,read\"/>\n"
+"<grant role=\"su\" entity-name=\"User\" actions=\"*\"/>]]>"
#. Tag: para
#: events.xml:182
#, no-c-format
msgid "The role names are the roles understood by your JACC provider."
msgstr "这些角色的名字就是你的 JACC provider 所定义的角色的名字。"
+
More information about the jboss-cvs-commits
mailing list