Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

update 

git-svn-id: https://svn.jboss.org/repos/hibernate/core/trunk@18997 1b8cb986-b30d-0410-93ca-fae66ebed9b2
This commit is contained in:
xhuang 2010-03-15 05:29:05 +00:00
parent f13430e23f
commit c937d0a393
13 changed files with 1691 additions and 6805 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
documentation/manual/src/main/docbook/zh-CN/Book_Info.po
View File

@ -5,24 +5,25 @@ msgid ""
msgstr ""
"Project-Id-Version: 0\n"
"POT-Creation-Date: 2010-03-12T00:03:45\n"
"PO-Revision-Date: 2010-02-04T04:51:21\n"
"Last-Translator: Automatically generated\n"
"PO-Revision-Date: 2010-03-15 08:44+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: None\n"
"MIME-Version: 1.0\n"
"Content-Type: application/x-publican; charset=UTF-8\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#. Tag: title
#, no-c-format
msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
msgstr ""
msgstr "HIBERNATE - Relational Persistence for Idiomatic Java"
#. Tag: subtitle
#, no-c-format
msgid "Hibernate Reference Documentation"
msgstr ""
msgstr "Hibernate Reference Documentation"
#. Tag: releaseinfo
#, no-c-format
msgid "&version;"
msgstr ""
msgstr "&version;"

14
documentation/manual/src/main/docbook/zh-CN/Hibernate_Reference.po
View File

@ -1,30 +1,30 @@
# SOME DESCRIPTIVE TITLE.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-11T05:38:14\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"PO-Revision-Date: 2010-03-15 08:45+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: LANGUAGE <kde-i18n-doc@kde.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: application/x-xml2pot; charset=UTF-8\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#. Tag: title
#, no-c-format
msgid "HIBERNATE - Relational Persistence for Idiomatic Java"
msgstr ""
msgstr "HIBERNATE - Relational Persistence for Idiomatic Java"
#. Tag: subtitle
#, no-c-format
msgid "Hibernate Reference Documentation"
msgstr ""
msgstr "Hibernate Reference Documentation"
#. Tag: releaseinfo
#, no-c-format
msgid "&versionNumber;"
msgstr ""
msgstr "&versionNumber;"

59
documentation/manual/src/main/docbook/zh-CN/author_group.po
View File

@ -6,8 +6,8 @@ msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-04T04:51:21\n"
"PO-Revision-Date: 2009-07-14 19:55+0000\n"
"Last-Translator: Automatically generated\n"
"PO-Revision-Date: 2010-03-15 08:43+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: none\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
@ -16,134 +16,135 @@ msgstr ""
#. Tag: firstname
#, no-c-format
msgid "Gavin"
msgstr ""
msgstr "Gavin"
#. Tag: firstname
#, no-c-format
msgid "Christian"
msgstr ""
msgstr "Christian"
#. Tag: firstname
#, no-c-format
msgid "Max"
msgstr ""
msgstr "Max"
#. Tag: firstname
#, no-c-format
msgid "Emmanuel"
msgstr ""
msgstr "Emmanuel"
#. Tag: firstname
#, no-c-format
msgid "Steve"
msgstr ""
msgstr "Steve"
#. Tag: firstname
#, no-c-format
msgid "James"
msgstr ""
msgstr "James"
#. Tag: firstname
#, no-c-format
msgid "Cheyenne"
msgstr ""
msgstr "Cheyenne"
#. Tag: firstname
#, no-c-format
msgid "Vincent"
msgstr ""
msgstr "Vincent"
#. Tag: firstname
#, no-c-format
msgid "Sebastien"
msgstr ""
msgstr "Sebastien"
#. Tag: firstname
#, no-c-format
msgid "Michael"
msgstr ""
msgstr "Michael"
#. Tag: firstname
#, no-c-format
msgid "Baptiste"
msgstr ""
msgstr "Baptiste"
#. Tag: firstname
#, no-c-format
msgid "Anthony"
msgstr ""
msgstr "Anthony"
#. Tag: firstname
#, no-c-format
msgid "Alvaro"
msgstr ""
msgstr "Alvaro"
#. Tag: firstname
#, no-c-format
msgid "Anderson"
msgstr ""
msgstr "Anderson"
#. Tag: firstname
#, no-c-format
msgid "Daniel Vieira"
msgstr ""
msgstr "Daniel Vieira"
#. Tag: firstname
#, no-c-format
msgid "Francisco"
msgstr ""
msgstr "Francisco"
#. Tag: firstname
#, no-c-format
msgid "Gamarra"
msgstr ""
msgstr "Gamarra"
#. Tag: firstname
#, no-c-format
msgid "Luiz Carlos"
msgstr ""
msgstr "Luiz Carlos"
#. Tag: firstname
#, no-c-format
msgid "Marcel"
msgstr ""
msgstr "Marcel"
#. Tag: firstname
#, no-c-format
msgid "Paulo"
msgstr ""
msgstr "Paulo"
#. Tag: firstname
#, no-c-format
msgid "Pablo L."
msgstr ""
msgstr "Pablo L."
#. Tag: firstname
#, no-c-format
msgid "Renato"
msgstr ""
msgstr "Renato"
#. Tag: firstname
#, no-c-format
msgid "Rogério"
msgstr ""
msgstr "Rogério"
#. Tag: firstname
#, no-c-format
msgid "Wanderson"
msgstr ""
msgstr "Wanderson"
#. Tag: firstname
#, no-c-format
msgid "Cao"
msgstr ""
msgstr "Cao"
#. Tag: orgname
#, no-c-format
msgid "RedSaga"
msgstr ""
msgstr "RedSaga"
#. Tag: contrib
#, no-c-format
msgid "Translation Lead"
msgstr ""
msgstr "Translation Lead"

441
documentation/manual/src/main/docbook/zh-CN/content/architecture.po
View File

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

3112
documentation/manual/src/main/docbook/zh-CN/content/basic_mapping.po
View File

File diff suppressed because it is too large Load Diff

349
documentation/manual/src/main/docbook/zh-CN/content/batch.po
View File

@ -6,7 +6,7 @@ msgstr ""
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-11T05:38:15\n"
"PO-Revision-Date: 2010-01-11 10:33+1000\n"
"PO-Revision-Date: 2010-03-15 08:58+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: <en@li.org>\n"
"MIME-Version: 1.0\n"
@ -21,62 +21,33 @@ msgstr "批量处理（Batch processing）"
#. Tag: para
#, no-c-format
msgid ""
"A naive approach to inserting 100,000 rows in the database using Hibernate "
"might look like this:"
msgstr ""
"使用 Hibernate 将 100,000 条记录插入到数据库的一个很天真的做法可能是这样的："
msgid "A naive approach to inserting 100,000 rows in the database using Hibernate might look like this:"
msgstr "使用 Hibernate 将 100,000 条记录插入到数据库的一个很天真的做法可能是这样的："
#. Tag: para
#, no-c-format
msgid ""
"This would fall over with an <literal>OutOfMemoryException</literal> "
"somewhere around the 50,000th row. That is because Hibernate caches all the "
"newly inserted <literal>Customer</literal> instances in the session-level "
"cache. In this chapter we will show you how to avoid this problem."
msgstr ""
"这段程序大概运行到 50，000 条记录左右会失败并抛出<literal>内存溢出异常"
"（OutOfMemoryException）</literal> 。这是因为 Hibernate 把所有新插入的"
"<literal>客户（Customer）</literal>实例在 session 级别的缓存区进行了缓存的缘"
"故。 "
msgid "This would fall over with an <literal>OutOfMemoryException</literal> somewhere around the 50,000th row. That is because Hibernate caches all the newly inserted <literal>Customer</literal> instances in the session-level cache. In this chapter we will show you how to avoid this problem."
msgstr "这段程序大概运行到 50，000 条记录左右会失败并抛出<literal>内存溢出异常（OutOfMemoryException）</literal> 。这是因为 Hibernate 把所有新插入的<literal>客户（Customer）</literal>实例在 session 级别的缓存区进行了缓存的缘故。 "
#. Tag: para
#, no-c-format
msgid ""
"If you are undertaking batch processing you will need to enable the use of "
"JDBC batching. This is absolutely essential if you want to achieve optimal "
"performance. Set the JDBC batch size to a reasonable number (10-50, for "
"example):"
msgstr ""
"我们会在本章告诉你如何避免此类问题。首先，如果你要执行批量处理并且想要达到一"
"个理想的性能，那么使用 JDBC 的批量（batching）功能是至关重要。将 JDBC 的批量"
"抓取数量（batch size）参数设置到一个合适值（比如，10 - 50 之间）："
msgid "If you are undertaking batch processing you will need to enable the use of JDBC batching. This is absolutely essential if you want to achieve optimal performance. Set the JDBC batch size to a reasonable number (10-50, for example):"
msgstr "我们会在本章告诉你如何避免此类问题。首先，如果你要执行批量处理并且想要达到一个理想的性能，那么使用 JDBC 的批量（batching）功能是至关重要。将 JDBC 的批量抓取数量（batch size）参数设置到一个合适值（比如，10 - 50 之间）："
#. Tag: para
#, no-c-format
msgid ""
"Hibernate disables insert batching at the JDBC level transparently if you "
"use an <literal>identity</literal> identifier generator."
msgstr ""
"注意，假若你使用了 <literal>identiy</literal> 标识符生成器，Hibernate 在 "
"JDBC 级别透明的关闭插入语句的批量执行。 "
msgid "Hibernate disables insert batching at the JDBC level transparently if you use an <literal>identity</literal> identifier generator."
msgstr "注意，假若你使用了 <literal>identiy</literal> 标识符生成器，Hibernate 在 JDBC 级别透明的关闭插入语句的批量执行。 "
#. Tag: para
#, no-c-format
msgid ""
"You can also do this kind of work in a process where interaction with the "
"second-level cache is completely disabled:"
msgid "You can also do this kind of work in a process where interaction with the second-level cache is completely disabled:"
msgstr "你也可能想在执行批量处理时完全关闭二级缓存："
#. Tag: para
#, no-c-format
msgid ""
"However, this is not absolutely necessary, since we can explicitly set the "
"<literal>CacheMode</literal> to disable interaction with the second-level "
"cache."
msgstr ""
"但是，这不是绝对必须的，因为我们可以显式设置 <literal>CacheMode</literal> 来"
"关闭与二级缓存的交互。"
msgid "However, this is not absolutely necessary, since we can explicitly set the <literal>CacheMode</literal> to disable interaction with the second-level cache."
msgstr "但是，这不是绝对必须的，因为我们可以显式设置 <literal>CacheMode</literal> 来关闭与二级缓存的交互。"
#. Tag: title
#, no-c-format
@ -85,13 +56,8 @@ msgstr "批量插入（Batch inserts）"
#. Tag: para
#, no-c-format
msgid ""
"When making new objects persistent <literal>flush()</literal> and then "
"<literal>clear()</literal> the session regularly in order to control the "
"size of the first-level cache."
msgstr ""
"如果要将很多对象持久化，你必须通过经常的调用 <literal>flush()</literal> 以及"
"稍后调用 <literal>clear()</literal> 来控制第一级缓存的大小。 "
msgid "When making new objects persistent <literal>flush()</literal> and then <literal>clear()</literal> the session regularly in order to control the size of the first-level cache."
msgstr "如果要将很多对象持久化，你必须通过经常的调用 <literal>flush()</literal> 以及稍后调用 <literal>clear()</literal> 来控制第一级缓存的大小。 "
#. Tag: title
#, no-c-format
@ -100,13 +66,8 @@ msgstr "批量更新（Batch updates）"
#. Tag: para
#, no-c-format
msgid ""
"For retrieving and updating data, the same ideas apply. In addition, you "
"need to use <literal>scroll()</literal> to take advantage of server-side "
"cursors for queries that return many rows of data."
msgstr ""
"此方法同样适用于检索和更新数据。此外，在进行会返回很多行数据的查询时，你需要"
"使用 <literal>scroll()</literal> 方法以便充分利用服务器端游标所带来的好处。 "
msgid "For retrieving and updating data, the same ideas apply. In addition, you need to use <literal>scroll()</literal> to take advantage of server-side cursors for queries that return many rows of data."
msgstr "此方法同样适用于检索和更新数据。此外，在进行会返回很多行数据的查询时，你需要使用 <literal>scroll()</literal> 方法以便充分利用服务器端游标所带来的好处。 "
#. Tag: title
#, no-c-format
@ -115,57 +76,18 @@ msgstr "StatelessSession（无状态 session）接口"
#. Tag: para
#, no-c-format
msgid ""
"Alternatively, Hibernate provides a command-oriented API that can be used "
"for streaming data to and from the database in the form of detached objects. "
"A <literal>StatelessSession</literal> has no persistence context associated "
"with it and does not provide many of the higher-level life cycle semantics. "
"In particular, a stateless session does not implement a first-level cache "
"nor interact with any second-level or query cache. It does not implement "
"transactional write-behind or automatic dirty checking. Operations performed "
"using a stateless session never cascade to associated instances. Collections "
"are ignored by a stateless session. Operations performed via a stateless "
"session bypass Hibernate's event model and interceptors. Due to the lack of "
"a first-level cache, Stateless sessions are vulnerable to data aliasing "
"effects. A stateless session is a lower-level abstraction that is much "
"closer to the underlying JDBC."
msgstr ""
"作为选择，Hibernate 提供了基于命令的 API，可以用 detached object 的形式把数据"
"以流的方法加入到数据库，或从数据库输出。<literal>StatelessSession</literal> "
"没有持久化上下文，也不提供多少高层的生命周期语义。特别是，无状态 session 不实"
"现第一级 cache，也不和第二级缓存，或者查询缓存交互。它不实现事务化写，也不实"
"现脏数据检查。用 stateless session 进行的操作甚至不级联到关联实例。stateless "
"session 忽略集合类（Collections）。通过 stateless session 进行的操作不触发 "
"Hibernate 的事件模型和拦截器。无状态 session 对数据的混淆现象免疫，因为它没有"
"第一级缓存。无状态 session 是低层的抽象，和低层 JDBC 相当接近。 "
msgid "Alternatively, Hibernate provides a command-oriented API that can be used for streaming data to and from the database in the form of detached objects. A <literal>StatelessSession</literal> has no persistence context associated with it and does not provide many of the higher-level life cycle semantics. In particular, a stateless session does not implement a first-level cache nor interact with any second-level or query cache. It does not implement transactional write-behind or automatic dirty checking. Operations performed using a stateless session never cascade to associated instances. Collections are ignored by a stateless session. Operations performed via a stateless session bypass Hibernate's event model and interceptors. Due to the lack of a first-level cache, Stateless sessions are vulnerable to data aliasing effects. A stateless session is a lower-level abstraction that is much closer to the underlying JDBC."
msgstr "作为选择，Hibernate 提供了基于命令的 API，可以用 detached object 的形式把数据以流的方法加入到数据库，或从数据库输出。<literal>StatelessSession</literal> 没有持久化上下文，也不提供多少高层的生命周期语义。特别是，无状态 session 不实现第一级 cache，也不和第二级缓存，或者查询缓存交互。它不实现事务化写，也不实现脏数据检查。用 stateless session 进行的操作甚至不级联到关联实例。stateless session 忽略集合类（Collections）。通过 stateless session 进行的操作不触发 Hibernate 的事件模型和拦截器。无状态 session 对数据的混淆现象免疫，因为它没有第一级缓存。无状态 session 是低层的抽象，和低层 JDBC 相当接近。 "
#. Tag: para
#, no-c-format
msgid ""
"In this code example, the <literal>Customer</literal> instances returned by "
"the query are immediately detached. They are never associated with any "
"persistence context."
msgstr ""
"注意在上面的例子中，查询返回的 <literal>Customer</literal> 实例立即被脱管"
"（detach）。它们与任何持久化上下文都没有关系。 "
msgid "In this code example, the <literal>Customer</literal> instances returned by the query are immediately detached. They are never associated with any persistence context."
msgstr "注意在上面的例子中，查询返回的 <literal>Customer</literal> 实例立即被脱管（detach）。它们与任何持久化上下文都没有关系。 "
#. Tag: para
#, no-c-format
msgid ""
"The <literal>insert(), update()</literal> and <literal>delete()</literal> "
"operations defined by the <literal>StatelessSession</literal> interface are "
"considered to be direct database row-level operations. They result in the "
"immediate execution of a SQL <literal>INSERT, UPDATE</literal> or "
"<literal>DELETE</literal> respectively. They have different semantics to the "
"<literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> "
"operations defined by the <literal>Session</literal> interface."
msgstr ""
"<literal>StatelessSession</literal> 接口定义的 <literal>insert(), update()</"
"literal> 和 <literal>delete()</literal> 操作是直接的数据库行级别操作，其结果"
"是立刻执行一条 <literal>INSERT, UPDATE</literal> 或 <literal>DELETE</"
"literal> 语句。因此，它们的语义和 <literal>Session</literal> 接口定义的 "
"<literal>save(), saveOrUpdate()</literal> 和<literal>delete()</literal> 操作"
"有很大的不同。 "
msgid "The <literal>insert(), update()</literal> and <literal>delete()</literal> operations defined by the <literal>StatelessSession</literal> interface are considered to be direct database row-level operations. They result in the immediate execution of a SQL <literal>INSERT, UPDATE</literal> or <literal>DELETE</literal> respectively. They have different semantics to the <literal>save(), saveOrUpdate()</literal> and <literal>delete()</literal> operations defined by the <literal>Session</literal> interface."
msgstr "<literal>StatelessSession</literal> 接口定义的 <literal>insert(), update()</literal> 和 <literal>delete()</literal> 操作是直接的数据库行级别操作，其结果是立刻执行一条 <literal>INSERT, UPDATE</literal> 或 <literal>DELETE</literal> 语句。因此，它们的语义和 <literal>Session</literal> 接口定义的 <literal>save(), saveOrUpdate()</literal> 和<literal>delete()</literal> 操作有很大的不同。 "
#. Tag: title
#, no-c-format
@ -173,36 +95,14 @@ msgid "DML-style operations"
msgstr "DML（数据操作语言）风格的操作（DML-style operations）"
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"As already discussed, automatic and transparent object/relational mapping is "
"concerned with the management of the object state. The object state is "
"available in memory. This means that manipulating data directly in the "
"database (using the SQL <literal>Data Manipulation Language</literal> (DML) "
"the statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, "
"<literal>DELETE</literal>) will not affect in-memory state. However, "
"Hibernate provides methods for bulk SQL-style DML statement execution that "
"is performed through the Hibernate Query Language (<link linkend=\"queryhql"
"\">HQL</link>)."
msgstr ""
"就像已经讨论的那样，自动和透明的对象/关系映射（object/relational mapping）关"
"注于管理对象的状态。这就意味着对象的状态存在于内存，因此直接操作（使用 SQL "
"<literal>Data Manipulation Language</literal>（DML,数据操作语言）语句 ："
"<literal>INSERT</literal> ,<literal>UPDATE</literal> 和 <literal>DELETE</"
"literal>） 数据库中的数据将不会影响内存中的对象状态和对象数据。不过，"
"Hibernate 提供通过 Hibernate 查询语言（<xref linkend=\"queryhql\"/>）来执行大"
"批量 SQL 风格的 DML 语句的方法。 "
#, no-c-format
msgid "As already discussed, automatic and transparent object/relational mapping is concerned with the management of the object state. The object state is available in memory. This means that manipulating data directly in the database (using the SQL <literal>Data Manipulation Language</literal> (DML) the statements: <literal>INSERT</literal>, <literal>UPDATE</literal>, <literal>DELETE</literal>) will not affect in-memory state. However, Hibernate provides methods for bulk SQL-style DML statement execution that is performed through the Hibernate Query Language (<link linkend=\"queryhql\">HQL</link>)."
msgstr "就像已经讨论的那样，自动和透明的对象/关系映射（object/relational mapping）关注于管理对象的状态。这就意味着对象的状态存在于内存，因此直接操作（使用 SQL <literal>Data Manipulation Language</literal>（DML,数据操作语言）语句 ：<literal>INSERT</literal> ,<literal>UPDATE</literal> 和 <literal>DELETE</literal>） 数据库中的数据将不会影响内存中的对象状态和对象数据。不过，Hibernate 提供通过 Hibernate 查询语言（<link linkend=\"queryhql\">HQL</link>）来执行大批量 SQL 风格的 DML 语句的方法。 "
#. Tag: para
#, no-c-format
msgid ""
"The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</"
"literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE "
"where_conditions)?</literal>."
msgstr ""
"<literal>UPDATE</literal> 和 <literal>DELETE</literal> 语句的伪语法为："
"<literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</"
"literal>。"
msgid "The pseudo-syntax for <literal>UPDATE</literal> and <literal>DELETE</literal> statements is: <literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>."
msgstr "<literal>UPDATE</literal> 和 <literal>DELETE</literal> 语句的伪语法为：<literal>( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?</literal>。"
#. Tag: para
#, no-c-format
@ -216,26 +116,13 @@ msgstr "在 FROM 子句（from-clause）中，FROM 关键字是可选的"
#. Tag: para
#, no-c-format
msgid ""
"There can only be a single entity named in the from-clause. It can, however, "
"be aliased. If the entity name is aliased, then any property references must "
"be qualified using that alias. If the entity name is not aliased, then it is "
"illegal for any property references to be qualified."
msgstr ""
"在 FROM 子句（from-clause）中只能有一个实体名，它可以是别名。如果实体名是别"
"名，那么任何被引用的属性都必须加上此别名的前缀；如果不是别名，那么任何有前缀"
"的属性引用都是非法的。 "
msgid "There can only be a single entity named in the from-clause. It can, however, be aliased. If the entity name is aliased, then any property references must be qualified using that alias. If the entity name is not aliased, then it is illegal for any property references to be qualified."
msgstr "在 FROM 子句（from-clause）中只能有一个实体名，它可以是别名。如果实体名是别名，那么任何被引用的属性都必须加上此别名的前缀；如果不是别名，那么任何有前缀的属性引用都是非法的。 "
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"No <link linkend=\"queryhql-joins-forms\">joins</link>, either implicit or "
"explicit, can be specified in a bulk HQL query. Sub-queries can be used in "
"the where-clause, where the subqueries themselves may contain joins."
msgstr ""
"不能在大批量 HQL 语句中使用 <xref linkend=\"queryhql-joins-forms\"/> 连接（显"
"式或者隐式的都不行）。不过在 WHERE 子句中可以使用子查询。可以在 where 子句中"
"使用子查询，子查询本身可以包含 join。 "
#, no-c-format
msgid "No <link linkend=\"queryhql-joins-forms\">joins</link>, 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 语句中使用 <link linkend=\"queryhql-joins-forms\">joins</link> 连接（显式或者隐式的都不行）。不过在 WHERE 子句中可以使用子查询。可以在 where 子句中使用子查询，子查询本身可以包含 join。 "
#. Tag: para
#, no-c-format
@ -244,182 +131,62 @@ msgstr "整个 WHERE 子句是可选的。"
#. Tag: para
#, no-c-format
msgid ""
"As an example, to execute an HQL <literal>UPDATE</literal>, use the "
"<literal>Query.executeUpdate()</literal> method. The method is named for "
"those familiar with JDBC's <literal>PreparedStatement.executeUpdate()</"
"literal>:"
msgstr ""
"举个例子，使用 <literal>Query.executeUpdate()</literal> 方法执行一个 HQL "
"<literal>UPDATE</literal>语句（方法命名是来源于 JDBC 的 "
"<literal>PreparedStatement.executeUpdate()</literal>）： "
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"In keeping with the EJB3 specification, HQL <literal>UPDATE</literal> "
"statements, by default, do not effect the <link linkend=\"mapping-"
"declaration-version\">version</link> or the <link linkend=\"mapping-"
"declaration-timestamp\">timestamp</link> 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> 关键"
"字来实现的。 "
msgid "As an example, to execute an HQL <literal>UPDATE</literal>, use the <literal>Query.executeUpdate()</literal> method. The method is named for those familiar with JDBC's <literal>PreparedStatement.executeUpdate()</literal>:"
msgstr "举个例子，使用 <literal>Query.executeUpdate()</literal> 方法执行一个 HQL <literal>UPDATE</literal>语句（方法命名是来源于 JDBC 的 <literal>PreparedStatement.executeUpdate()</literal>）： "
#. Tag: para
#, no-c-format
msgid ""
"Custom version types, <literal>org.hibernate.usertype.UserVersionType</"
"literal>, are not allowed in conjunction with a <literal>update versioned</"
"literal> statement."
msgstr ""
"注意，自定义的版本类型（<literal>org.hibernate.usertype.UserVersionType</"
"literal>）不允许和 <literal>update versioned</literal> 语句联用。 "
msgid "In keeping with the EJB3 specification, HQL <literal>UPDATE</literal> statements, by default, do not effect the <link linkend=\"mapping-declaration-version\">version</link> or the <link linkend=\"mapping-declaration-timestamp\">timestamp</link> 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> 语句，默认不会影响更新实体的 <link linkend=\"mapping-declaration-version\">version</link> 或 the <link linkend=\"mapping-declaration-timestamp\">timestamp</link> 属性值。这和 EJB3 规范是一致的。但是，通过使用 <literal>versioned update</literal>，你可以强制 Hibernate 正确的重置<literal>version</literal> 或者 <literal>timestamp</literal> 属性值。这通过在 <literal>UPDATE</literal> 关键字后面增加 <literal>VERSIONED</literal> 关键字来实现的。 "
#. Tag: para
#, no-c-format
msgid ""
"To execute an HQL <literal>DELETE</literal>, use the same <literal>Query."
"executeUpdate()</literal> method:"
msgstr ""
"执行一个 HQL <literal>DELETE</literal>，同样使用 <literal>Query.executeUpdate"
"()</literal> 方法："
msgid "Custom version types, <literal>org.hibernate.usertype.UserVersionType</literal>, are not allowed in conjunction with a <literal>update versioned</literal> statement."
msgstr "注意，自定义的版本类型（<literal>org.hibernate.usertype.UserVersionType</literal>）不允许和 <literal>update versioned</literal> 语句联用。 "
#. Tag: para
#, no-c-format
msgid ""
"The <literal>int</literal> value returned by the <literal>Query.executeUpdate"
"()</literal> method indicates the number of entities effected by the "
"operation. This may or may not correlate to the number of rows effected in "
"the database. An HQL bulk operation might result in multiple actual SQL "
"statements being executed (for joined-subclass, for example). The returned "
"number indicates the number of actual entities affected by the statement. "
"Going back to the example of joined-subclass, a delete against one of the "
"subclasses may actually result in deletes against not just the table to "
"which that subclass is mapped, but also the \"root\" table and potentially "
"joined-subclass tables further down the inheritance hierarchy."
msgstr ""
"由 <literal>Query.executeUpdate()</literal> 方法返回的<literal>整型</literal>"
"值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条 SQL 语"
"句）影响了的“行”数有关，也可能没有。一个大批量 HQL 操作可能导致多条实际的SQL"
"语句被执行，举个例子，对 joined-subclass 映射方式的类进行的此类操作。这个返回"
"值代表了实际被语句影响了的记录数量。在那个 joined-subclass 的例子中， 对一个"
"子类的删除实际上可能不仅仅会删除子类映射到的表而且会影响“根”表，还有可能影响"
"与之有继承关系的 joined-subclass 映射方式的子类的表。 "
msgid "To execute an HQL <literal>DELETE</literal>, use the same <literal>Query.executeUpdate()</literal> method:"
msgstr "执行一个 HQL <literal>DELETE</literal>，同样使用 <literal>Query.executeUpdate()</literal> 方法："
#. Tag: para
#, no-c-format
msgid ""
"The 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 <literal>int</literal> value returned by the <literal>Query.executeUpdate()</literal> method indicates the number of entities effected by the operation. This may or may not correlate to the number of rows effected in the database. An HQL bulk operation might result in multiple actual SQL statements being executed (for joined-subclass, for example). The returned number indicates the number of actual entities affected by the statement. Going back to the example of joined-subclass, a delete against one of the subclasses may actually result in deletes against not just the table to which that subclass is mapped, but also the \"root\" table and potentially joined-subclass tables further down the inheritance hierarchy."
msgstr "由 <literal>Query.executeUpdate()</literal> 方法返回的<literal>整型</literal>值表明了受此操作影响的记录数量。注意这个数值可能与数据库中被（最后一条 SQL 语句）影响了的“行”数有关，也可能没有。一个大批量 HQL 操作可能导致多条实际的SQL语句被执行，举个例子，对 joined-subclass 映射方式的类进行的此类操作。这个返回值代表了实际被语句影响了的记录数量。在那个 joined-subclass 的例子中， 对一个子类的删除实际上可能不仅仅会删除子类映射到的表而且会影响“根”表，还有可能影响与之有继承关系的 joined-subclass 映射方式的子类的表。 "
#. Tag: para
#, no-c-format
msgid ""
"Only the INSERT INTO ... SELECT ... form is supported; not the INSERT "
"INTO ... VALUES ... form."
msgstr ""
"只支持 INSERT INTO ... SELECT ... 形式，不支持 INSERT INTO ... VALUES ... 形"
"式。"
msgid "The pseudo-syntax for <literal>INSERT</literal> statements is: <literal>INSERT INTO EntityName properties_list select_statement</literal>. Some points to note:"
msgstr "<literal>INSERT</literal> 语句的伪码是：<literal>INSERT INTO EntityName properties_list select_statement</literal>。要注意的是："
#. Tag: para
#, no-c-format
msgid ""
"The properties_list is analogous to the <literal>column specification</"
"literal> in the SQL <literal>INSERT</literal> statement. For entities "
"involved in mapped inheritance, only properties directly defined on that "
"given class-level can be used in the properties_list. Superclass properties "
"are not allowed and subclass properties do not make sense. In other words, "
"<literal>INSERT</literal> statements are inherently non-polymorphic."
msgstr ""
"properties_list 和 SQL <literal>INSERT</literal> 语句中的<literal>字段定义"
"（column speficiation）</literal>类似。对参与继承树映射的实体而言，只有直接定"
"义在给定的类级别的属性才能直接在 properties_list 中使用。超类的属性不被支持；"
"子类的属性无意义。换句话说，<literal>INSERT</literal> 天生不支持多态性。"
msgid "Only the INSERT INTO ... SELECT ... form is supported; not the INSERT INTO ... VALUES ... form."
msgstr "只支持 INSERT INTO ... SELECT ... 形式，不支持 INSERT INTO ... VALUES ... 形式。"
#. Tag: para
#, no-c-format
msgid ""
"select_statement can be any valid HQL select query, with the caveat that the "
"return types must match the types expected by the insert. Currently, this is "
"checked during query compilation rather than allowing the check to relegate "
"to the database. This might, however, cause problems between Hibernate "
"<literal>Type</literal>s which are <emphasis>equivalent</emphasis> as "
"opposed to <emphasis>equal</emphasis>. This might cause issues with "
"mismatches between a property defined as a <literal>org.hibernate.type."
"DateType</literal> and a property defined as a <literal>org.hibernate.type."
"TimestampType</literal>, even though the database might not make a "
"distinction or might be able to handle the conversion."
msgstr ""
"select_statement 可以是任何合法的 HQL 选择查询，不过要保证返回类型必须和要插"
"入的类型完全匹配。目前，这一检查是在查询编译的时候进行的，而不是把它交给数据"
"库。注意，在Hibernate<literal>Type</literal> 间如果只是<emphasis>等价"
"（equivalent）</emphasis>而非<emphasis>相等（equal）</emphasis>，会导致问题。"
"定义为 <literal>org.hibernate.type.DateType</literal> 和 <literal>org."
"hibernate.type.TimestampType</literal> 的两个属性可能会产生类型不匹配错误，虽"
"然数据库级可能不加区分或者可以处理这种转换。 "
msgid "The properties_list is analogous to the <literal>column specification</literal> in the SQL <literal>INSERT</literal> statement. For entities involved in mapped inheritance, only properties directly defined on that given class-level can be used in the properties_list. Superclass properties are not allowed and subclass properties do not make sense. In other words, <literal>INSERT</literal> statements are inherently non-polymorphic."
msgstr "properties_list 和 SQL <literal>INSERT</literal> 语句中的<literal>字段定义（column speficiation）</literal>类似。对参与继承树映射的实体而言，只有直接定义在给定的类级别的属性才能直接在 properties_list 中使用。超类的属性不被支持；子类的属性无意义。换句话说，<literal>INSERT</literal> 天生不支持多态性。"
#. Tag: para
#, no-c-format
msgid ""
"For the id property, the insert statement gives you two options. You can "
"either explicitly specify the id property in the properties_list, in which "
"case its value is taken from the corresponding select expression, or omit it "
"from the properties_list, in which case a generated value is used. This "
"latter option is only available when using id generators that operate in the "
"database; attempting to use this option with any \"in memory\" type "
"generators will cause an exception during parsing. For the purposes of this "
"discussion, in-database generators are considered to be <literal>org."
"hibernate.id.SequenceGenerator</literal> (and its subclasses) and any "
"implementers of <literal>org.hibernate.id.PostInsertIdentifierGenerator</"
"literal>. The most notable exception here is <literal>org.hibernate.id."
"TableHiLoGenerator</literal>, which cannot be used because it does not "
"expose a selectable way to get its values."
msgstr ""
"对 id 属性来说，insert 语句给你两个选择。你可以明确地在 properties_list 表中"
"指定 id 属性（这样它的值是从对应的 select 表达式中获得），或者在 "
"properties_list 中省略它（此时使用生成指）。后一种选择只有当使用在数据库中生"
"成值的 id 产生器时才能使用；如果是“内存”中计算的类型生成器，在解析时会抛出一"
"个异常。注意，为了说明这一问题，数据库产生值的生成器是 <literal>org."
"hibernate.id.SequenceGenerator</literal>（和它的子类），以及任何 "
"<literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> 接口的实"
"现。这儿最值得注意的意外是 <literal>org.hibernate.id.TableHiLoGenerator</"
"literal>，它不能在此使用，因为它没有得到其值的途径。 "
msgid "select_statement can be any valid HQL select query, with the caveat that the return types must match the types expected by the insert. Currently, this is checked during query compilation rather than allowing the check to relegate to the database. This might, however, cause problems between Hibernate <literal>Type</literal>s which are <emphasis>equivalent</emphasis> as opposed to <emphasis>equal</emphasis>. This might cause issues with mismatches between a property defined as a <literal>org.hibernate.type.DateType</literal> and a property defined as a <literal>org.hibernate.type.TimestampType</literal>, even though the database might not make a distinction or might be able to handle the conversion."
msgstr "select_statement 可以是任何合法的 HQL 选择查询，不过要保证返回类型必须和要插入的类型完全匹配。目前，这一检查是在查询编译的时候进行的，而不是把它交给数据库。注意，在Hibernate<literal>Type</literal> 间如果只是<emphasis>等价（equivalent）</emphasis>而非<emphasis>相等（equal）</emphasis>，会导致问题。定义为 <literal>org.hibernate.type.DateType</literal> 和 <literal>org.hibernate.type.TimestampType</literal> 的两个属性可能会产生类型不匹配错误，虽然数据库级可能不加区分或者可以处理这种转换。 "
#. Tag: para
#, no-c-format
msgid ""
"For properties mapped as either <literal>version</literal> or "
"<literal>timestamp</literal>, the insert statement gives you two options. "
"You can either specify the property in the properties_list, in which case "
"its value is taken from the corresponding select expressions, or omit it "
"from the properties_list, in which case the <literal>seed value</literal> "
"defined by the <literal>org.hibernate.type.VersionType</literal> is used."
msgstr ""
"对映射为 <literal>version</literal> 或 <literal>timestamp</literal> 的属性来"
"说，insert 语句也给你两个选择，你可以在 properties_list 表中指定（此时其值从"
"对应的 select 表达式中获得），或者在 properties_list 中省略它（此时，使用在 "
"<literal>org.hibernate.type.VersionType</literal> 中定义的 <literal>seed "
"value（种子值）</literal>）。"
msgid "For the id property, the insert statement gives you two options. You can either explicitly specify the id property in the properties_list, in which case its value is taken from the corresponding select expression, or omit it from the properties_list, in which case a generated value is used. This latter option is only available when using id generators that operate in the database; attempting to use this option with any \"in memory\" type generators will cause an exception during parsing. For the purposes of this discussion, in-database generators are considered to be <literal>org.hibernate.id.SequenceGenerator</literal> (and its subclasses) and any implementers of <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal>. The most notable exception here is <literal>org.hibernate.id.TableHiLoGenerator</literal>, which cannot be used because it does not expose a selectable way to get its values."
msgstr "对 id 属性来说，insert 语句给你两个选择。你可以明确地在 properties_list 表中指定 id 属性（这样它的值是从对应的 select 表达式中获得），或者在 properties_list 中省略它（此时使用生成指）。后一种选择只有当使用在数据库中生成值的 id 产生器时才能使用；如果是“内存”中计算的类型生成器，在解析时会抛出一个异常。注意，为了说明这一问题，数据库产生值的生成器是 <literal>org.hibernate.id.SequenceGenerator</literal>（和它的子类），以及任何 <literal>org.hibernate.id.PostInsertIdentifierGenerator</literal> 接口的实现。这儿最值得注意的意外是 <literal>org.hibernate.id.TableHiLoGenerator</literal>，它不能在此使用，因为它没有得到其值的途径。 "
#. Tag: para
#, no-c-format
msgid ""
"The following is an example of an HQL <literal>INSERT</literal> statement "
"execution:"
msgid "For properties mapped as either <literal>version</literal> or <literal>timestamp</literal>, the insert statement gives you two options. You can either specify the property in the properties_list, in which case its value is taken from the corresponding select expressions, or omit it from the properties_list, in which case the <literal>seed value</literal> defined by the <literal>org.hibernate.type.VersionType</literal> is used."
msgstr "对映射为 <literal>version</literal> 或 <literal>timestamp</literal> 的属性来说，insert 语句也给你两个选择，你可以在 properties_list 表中指定（此时其值从对应的 select 表达式中获得），或者在 properties_list 中省略它（此时，使用在 <literal>org.hibernate.type.VersionType</literal> 中定义的 <literal>seed value（种子值）</literal>）。"
#. Tag: para
#, no-c-format
msgid "The following is an example of an HQL <literal>INSERT</literal> statement execution:"
msgstr "下面是一个执行 HQL <literal>INSERT</literal> 语句的例子："
#~ msgid ""

19
documentation/manual/src/main/docbook/zh-CN/content/bibliography.po
View File

@ -6,8 +6,8 @@ msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-04T04:51:21\n"
"PO-Revision-Date: 2009-07-14 19:55+0000\n"
"Last-Translator: Automatically generated\n"
"PO-Revision-Date: 2010-03-15 08:58+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: none\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
@ -16,34 +16,35 @@ msgstr ""
#. Tag: title
#, no-c-format
msgid "References"
msgstr ""
msgstr "参考资料"
#. Tag: title
#, no-c-format
msgid "Patterns of Enterprise Application Architecture"
msgstr ""
msgstr "Patterns of Enterprise Application Architecture"
#. Tag: firstname
#, no-c-format
msgid "Martin"
msgstr ""
msgstr "Martin"
#. Tag: title
#, no-c-format
msgid "Java Persistence with Hibernate"
msgstr ""
msgstr "Java Persistence with Hibernate"
#. Tag: subtitle
#, no-c-format
msgid "Second Edition of Hibernate in Action"
msgstr ""
msgstr "Second Edition of Hibernate in Action"
#. Tag: firstname
#, no-c-format
msgid "Christian"
msgstr ""
msgstr "Christian"
#. Tag: firstname
#, no-c-format
msgid "Gavin"
msgstr ""
msgstr "Gavin"

831
documentation/manual/src/main/docbook/zh-CN/content/collection_mapping.po
View File

File diff suppressed because it is too large Load Diff

288
documentation/manual/src/main/docbook/zh-CN/content/component_mapping.po
View File

@ -6,7 +6,7 @@ msgstr ""
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-11T05:38:15\n"
"PO-Revision-Date: 2010-01-11 10:36+1000\n"
"PO-Revision-Date: 2010-03-15 09:01+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: <en@li.org>\n"
"MIME-Version: 1.0\n"
@ -21,12 +21,8 @@ msgstr "组件（Component）映射"
#. Tag: para
#, no-c-format
msgid ""
"The notion of a <emphasis>component</emphasis> is re-used in several "
"different contexts and purposes throughout Hibernate."
msgstr ""
"<emphasis>组件（Component）</emphasis>这个概念在 Hibernate 中几处不同的地方为"
"了不同的目的被重复使用。"
msgid "The notion of a <emphasis>component</emphasis> is re-used in several different contexts and purposes throughout Hibernate."
msgstr "<emphasis>组件（Component）</emphasis>这个概念在 Hibernate 中几处不同的地方为了不同的目的被重复使用。"
#. Tag: title
#, no-c-format
@ -35,29 +31,13 @@ msgstr "依赖对象（Dependent objects）"
#. Tag: para
#, no-c-format
msgid ""
"A component is a contained object that is persisted as a value type and not "
"an entity reference. The term \"component\" refers to the object-oriented "
"notion of composition and not to architecture-level components. For example, "
"you can model a person like this:"
msgstr ""
"组件（Component）是一个被包含的对象，在持久化的过程中，它被当作值类型，而并非"
"一个实体的引用。在这篇文档中，组件这一术语指的是面向对象的合成概念（而并不是"
"系统构架层次上的组件的概念）。举个例子，你对人（Person）这个概念可以像下面这"
"样来建模： "
msgid "A component is a contained object that is persisted as a value type and not an entity reference. The term \"component\" refers to the object-oriented notion of composition and not to architecture-level components. For example, you can model a person like this:"
msgstr "组件（Component）是一个被包含的对象，在持久化的过程中，它被当作值类型，而并非一个实体的引用。在这篇文档中，组件这一术语指的是面向对象的合成概念（而并不是系统构架层次上的组件的概念）。举个例子，你对人（Person）这个概念可以像下面这样来建模： "
#. Tag: para
#, no-c-format
msgid ""
"Now <literal>Name</literal> can be persisted as a component of "
"<literal>Person</literal>. <literal>Name</literal> defines getter and setter "
"methods for its persistent properties, but it does not need to declare any "
"interfaces or identifier properties."
msgstr ""
"在持久化的过程中，<literal>姓名（Name）</literal>可以作为<literal>人"
"（Person）</literal>的一个组件。需要注意的是：你应该为<literal>姓名</literal>"
"的持久化属性定义 getter 和 setter 方法，但是你不需要实现任何的接口或申明标识"
"符字段。 "
msgid "Now <literal>Name</literal> can be persisted as a component of <literal>Person</literal>. <literal>Name</literal> defines getter and setter methods for its persistent properties, but it does not need to declare any interfaces or identifier properties."
msgstr "在持久化的过程中，<literal>姓名（Name）</literal>可以作为<literal>人（Person）</literal>的一个组件。需要注意的是：你应该为<literal>姓名</literal>的持久化属性定义 getter 和 setter 方法，但是你不需要实现任何的接口或申明标识符字段。 "
#. Tag: para
#, no-c-format
@ -66,54 +46,23 @@ msgstr "以下是这个例子的 Hibernate 映射文件： "
#. Tag: para
#, no-c-format
msgid ""
"The person table would have the columns <literal>pid</literal>, "
"<literal>birthday</literal>, <literal>initial</literal>, <literal>first</"
"literal> and <literal>last</literal>."
msgstr ""
"人员（Person）表中将包括 <literal>pid</literal>，<literal>birthday</"
"literal>，<literal>initial</literal>，<literal>first</literal>和 "
"<literal>last</literal> 等字段。"
msgid "The person table would have the columns <literal>pid</literal>, <literal>birthday</literal>, <literal>initial</literal>, <literal>first</literal> and <literal>last</literal>."
msgstr "人员（Person）表中将包括 <literal>pid</literal>，<literal>birthday</literal>，<literal>initial</literal>，<literal>first</literal>和 <literal>last</literal> 等字段。"
#. Tag: para
#, no-c-format
msgid ""
"Like value types, components do not support shared references. In other "
"words, two persons could have the same name, but the two person objects "
"would contain two independent name objects that were only \"the same\" by "
"value. The null value semantics of a component are <emphasis>ad hoc</"
"emphasis>. When reloading the containing object, Hibernate will assume that "
"if all component columns are null, then the entire component is null. This "
"is suitable for most purposes."
msgstr ""
"就像所有的值类型一样，组件不支持共享引用。换句话说，两个人可能重名，但是两个 "
"Person 对象应该包含两个独立的 Name 对象，只不过这两个 Name 对象具有“同样”的"
"值。组件的值可以为空，其定义如下。 每当 Hibernate 重新加载一个包含组件的对"
"象，如果该组件的所有字段为空，Hibernate 将假定整个组件为空。在大多数情况下，"
"这样假定应该是没有问题的。"
msgid "Like value types, components do not support shared references. In other words, two persons could have the same name, but the two person objects would contain two independent name objects that were only \"the same\" by value. The null value semantics of a component are <emphasis>ad hoc</emphasis>. When reloading the containing object, Hibernate will assume that if all component columns are null, then the entire component is null. This is suitable for most purposes."
msgstr "就像所有的值类型一样，组件不支持共享引用。换句话说，两个人可能重名，但是两个 Person 对象应该包含两个独立的 Name 对象，只不过这两个 Name 对象具有“同样”的值。组件的值可以为空，其定义如下。 每当 Hibernate 重新加载一个包含组件的对象，如果该组件的所有字段为空，Hibernate 将假定整个组件为空。在大多数情况下，这样假定应该是没有问题的。"
#. Tag: para
#, no-c-format
msgid ""
"The properties of a component can be of any Hibernate type (collections, "
"many-to-one associations, other components, etc). Nested components should "
"<emphasis>not</emphasis> be considered an exotic usage. Hibernate is "
"intended to support a fine-grained object model."
msgstr ""
"组件的属性可以是任意一种 Hibernate 类型（包括集合，多对多关联，以及其它组件等"
"等）。嵌套组件不应该被当作一种特殊的应用（Nested components should not be "
"considered an exotic usage）。Hibernate 倾向于支持细颗粒度的（fine-grained）"
"对象模型。"
msgid "The properties of a component can be of any Hibernate type (collections, many-to-one associations, other components, etc). Nested components should <emphasis>not</emphasis> be considered an exotic usage. Hibernate is intended to support a fine-grained object model."
msgstr "组件的属性可以是任意一种 Hibernate 类型（包括集合，多对多关联，以及其它组件等等）。嵌套组件不应该被当作一种特殊的应用（Nested components should not be considered an exotic usage）。Hibernate 倾向于支持细颗粒度的（fine-grained）对象模型。"
#. Tag: para
#, no-c-format
msgid ""
"The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;"
"parent&gt;</literal> subelement that maps a property of the component class "
"as a reference back to the containing entity."
msgstr ""
"<literal>&lt;component&gt;</literal> 元素允许加入一个 <literal>&lt;parent&gt;"
"</literal> 子元素，在组件类内部就可以有一个指向其容器的实体的反向引用。"
msgid "The <literal>&lt;component&gt;</literal> element allows a <literal>&lt;parent&gt;</literal> subelement that maps a property of the component class as a reference back to the containing entity."
msgstr "<literal>&lt;component&gt;</literal> 元素允许加入一个 <literal>&lt;parent&gt;</literal> 子元素，在组件类内部就可以有一个指向其容器的实体的反向引用。"
#. Tag: title
#, no-c-format
@ -121,94 +70,34 @@ msgid "Collections of dependent objects"
msgstr "在集合中出现的依赖对象（Collections of dependent objects）"
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Collections of components are supported (e.g. an array of type "
"<literal>Name</literal>). Declare your component collection by replacing the "
"<literal>&lt;element&gt;</literal> tag with a <literal>&lt;composite-"
"element&gt;</literal> tag:"
msgstr ""
"Hibernate 支持组件的集合（例如：一个元素是姓名（Name）这种类型的数组）。你可"
"以使用 <literal>&lt;composite-element&gt;</literal> 标签替代 <literal>&lt;"
"element&gt;</literal> 标签来定义你的组件集合。"
#, no-c-format
msgid "Collections of components are supported (e.g. an array of type <literal>Name</literal>). Declare your component collection by replacing the <literal>&lt;element&gt;</literal> tag with a <literal>&lt;composite-element&gt;</literal> tag:"
msgstr "Hibernate 支持组件的集合（例如：一个元素是姓名 <literal>Name</literal> 这种类型的数组）。你可以使用 <literal>&lt;composite-element&gt;</literal> 标签替代 <literal>&lt;element&gt;</literal> 标签来定义你的组件集合。"
#. Tag: para
#, no-c-format
msgid ""
"If you define a <literal>Set</literal> of composite elements, it is "
"important to implement <literal>equals()</literal> and <literal>hashCode()</"
"literal> correctly."
msgstr ""
"注意，如果你定义的 Set 包含组合元素（composite-element），正确地实现 "
"<literal>equals()</literal> 和 <literal>hashCode()</literal> 是非常重要的。 "
msgid "If you define a <literal>Set</literal> of composite elements, it is important to implement <literal>equals()</literal> and <literal>hashCode()</literal> correctly."
msgstr "注意，如果你定义的 Set 包含组合元素（composite-element），正确地实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> 是非常重要的。 "
#. Tag: para
#, no-c-format
msgid ""
"Composite elements can contain components but not collections. If your "
"composite element contains components, use the <literal>&lt;nested-composite-"
"element&gt;</literal> tag. This case is a collection of components which "
"themselves have components. You may want to consider if a one-to-many "
"association is more appropriate. Remodel the composite element as an entity, "
"but be aware that even though the Java model is the same, the relational "
"model and persistence semantics are still slightly different."
msgstr ""
"组合元素可以包含组件，但是不能包含集合。如果你的组合元素自身包含组件，你必须"
"使用 <literal>&lt;nested-composite-element&gt;</literal> 标签。这是一个相当特"
"殊的案例 — 在一个组件的集合里，那些组件本身又可以包含其他的组件。这个时候你就"
"应该考虑一下使用 one-to-many 关联是否会更恰当。尝试对这个组合元素重新建模为一"
"个实体 — 但是需要注意的是，虽然 Java 模型和重新建模前是一样的，关系模型和持久"
"性语义会有细微的变化。 "
msgid "Composite elements can contain components but not collections. If your composite element contains components, use the <literal>&lt;nested-composite-element&gt;</literal> tag. This case is a collection of components which themselves have components. You may want to consider if a one-to-many association is more appropriate. Remodel the composite element as an entity, but be aware that even though the Java model is the same, the relational model and persistence semantics are still slightly different."
msgstr "组合元素可以包含组件，但是不能包含集合。如果你的组合元素自身包含组件，你必须使用 <literal>&lt;nested-composite-element&gt;</literal> 标签。这是一个相当特殊的案例 — 在一个组件的集合里，那些组件本身又可以包含其他的组件。这个时候你就应该考虑一下使用 one-to-many 关联是否会更恰当。尝试对这个组合元素重新建模为一个实体 — 但是需要注意的是，虽然 Java 模型和重新建模前是一样的，关系模型和持久性语义会有细微的变化。 "
#. Tag: para
#, no-c-format
msgid ""
"A composite element mapping does not support null-able properties if you are "
"using a <literal>&lt;set&gt;</literal>. There is no separate primary key "
"column in the composite element table. Hibernate uses each column's value to "
"identify a record when deleting objects, which is not possible with null "
"values. You have to either use only not-null properties in a composite-"
"element or choose a <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</"
"literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>."
msgstr ""
"请注意如果你使用 <literal>&lt;set&gt;</literal> 标签，一个组合元素的映射不支"
"持可能为空的属性. 当删除对象时，Hibernate 必须使用每一个字段的值来确定一条记"
"录（在组合元素表中，没有单独的关键字段），如果有为 null 的字段，这样做就不可"
"能了。你必须作出一个选择，要么在组合元素中使用不能为空的属性，要么选择使用 "
"<literal>&lt;list&gt;</literal>，<literal>&lt;map&gt;</literal>，"
"<literal>&lt;bag&gt;</literal> 或者 <literal>&lt;idbag&gt;</literal> 而不是 "
"<literal>&lt;set&gt;</literal>。 "
msgid "A composite element mapping does not support null-able properties if you are using a <literal>&lt;set&gt;</literal>. There is no separate primary key column in the composite element table. Hibernate uses each column's value to identify a record when deleting objects, which is not possible with null values. You have to either use only not-null properties in a composite-element or choose a <literal>&lt;list&gt;</literal>, <literal>&lt;map&gt;</literal>, <literal>&lt;bag&gt;</literal> or <literal>&lt;idbag&gt;</literal>."
msgstr "请注意如果你使用 <literal>&lt;set&gt;</literal> 标签，一个组合元素的映射不支持可能为空的属性. 当删除对象时，Hibernate 必须使用每一个字段的值来确定一条记录（在组合元素表中，没有单独的关键字段），如果有为 null 的字段，这样做就不可能了。你必须作出一个选择，要么在组合元素中使用不能为空的属性，要么选择使用 <literal>&lt;list&gt;</literal>，<literal>&lt;map&gt;</literal>，<literal>&lt;bag&gt;</literal> 或者 <literal>&lt;idbag&gt;</literal> 而不是 <literal>&lt;set&gt;</literal>。 "
#. Tag: para
#, no-c-format
msgid ""
"A special case of a composite element is a composite element with a nested "
"<literal>&lt;many-to-one&gt;</literal> element. This mapping allows you to "
"map extra columns of a many-to-many association table to the composite "
"element class. The following is a many-to-many association from "
"<literal>Order</literal> to <literal>Item</literal>, where "
"<literal>purchaseDate</literal>, <literal>price</literal> and "
"<literal>quantity</literal> are properties of the association:"
msgstr ""
"组合元素有个特别的用法是它可以包含一个<literal>&lt;many-to-one&gt;</literal>"
"元素。类似这样的映射允许你将一个 many-to-many 关联表的额外字段映射为组合元素"
"类。接下来的的例子是从 <literal>Order</literal> 到 <literal>Item</literal> 的"
"一个多对多的关联关系，关联属性是 <literal>purchaseDate</literal>，"
"<literal>price</literal> 和 <literal>quantity</literal> 。 "
msgid "A special case of a composite element is a composite element with a nested <literal>&lt;many-to-one&gt;</literal> element. This mapping allows you to map extra columns of a many-to-many association table to the composite element class. The following is a many-to-many association from <literal>Order</literal> to <literal>Item</literal>, where <literal>purchaseDate</literal>, <literal>price</literal> and <literal>quantity</literal> are properties of the association:"
msgstr "组合元素有个特别的用法是它可以包含一个<literal>&lt;many-to-one&gt;</literal>元素。类似这样的映射允许你将一个 many-to-many 关联表的额外字段映射为组合元素类。接下来的的例子是从 <literal>Order</literal> 到 <literal>Item</literal> 的一个多对多的关联关系，关联属性是 <literal>purchaseDate</literal>，<literal>price</literal> 和 <literal>quantity</literal> 。 "
#. Tag: para
#, no-c-format
msgid ""
"There cannot be a reference to the purchase on the other side for "
"bidirectional association navigation. Components are value types and do not "
"allow shared references. A single <literal>Purchase</literal> can be in the "
"set of an <literal>Order</literal>, but it cannot be referenced by the "
"<literal>Item</literal> at the same time."
msgstr ""
"当然，当你定义 Item 时，你无法引用这些 purchase，因此你无法实现双向关联查询。"
"记住组件是值类型，并且不允许共享引用。某一个特定的 <literal>Purchase</"
"literal> 可以放在 <literal>Order</literal> 的集合中，但它不能同时被 "
"<literal>Item</literal> 所引用。 "
msgid "There cannot be a reference to the purchase on the other side for bidirectional association navigation. Components are value types and do not allow shared references. A single <literal>Purchase</literal> can be in the set of an <literal>Order</literal>, but it cannot be referenced by the <literal>Item</literal> at the same time."
msgstr "当然，当你定义 Item 时，你无法引用这些 purchase，因此你无法实现双向关联查询。记住组件是值类型，并且不允许共享引用。某一个特定的 <literal>Purchase</literal> 可以放在 <literal>Order</literal> 的集合中，但它不能同时被 <literal>Item</literal> 所引用。 "
#. Tag: para
#, no-c-format
@ -217,9 +106,7 @@ msgstr "其实组合元素的这个用法可以扩展到三重或多重关联:"
#. Tag: para
#, no-c-format
msgid ""
"Composite elements can appear in queries using the same syntax as "
"associations to other entities."
msgid "Composite elements can appear in queries using the same syntax as associations to other entities."
msgstr "在查询中，表达组合元素的语法和关联到其他实体的语法是一样的。 "
#. Tag: title
@ -229,15 +116,8 @@ msgstr "组件作为 Map 的索引（Components as Map indices ）"
#. Tag: para
#, no-c-format
msgid ""
"The <literal>&lt;composite-map-key&gt;</literal> element allows you to map a "
"component class as the key of a <literal>Map</literal>. Ensure that you "
"override <literal>hashCode()</literal> and <literal>equals()</literal> "
"correctly on the component class."
msgstr ""
"<literal>&lt;composite-map-key&gt;</literal> 元素允许你映射一个组件类作为一"
"个 <literal>Map</literal> 的 key，前提是你必须正确的在这个类中重写了 "
"<literal>hashCode()</literal> 和 <literal>equals()</literal> 方法。 "
msgid "The <literal>&lt;composite-map-key&gt;</literal> element allows you to map a component class as the key of a <literal>Map</literal>. Ensure that you override <literal>hashCode()</literal> and <literal>equals()</literal> correctly on the component class."
msgstr "<literal>&lt;composite-map-key&gt;</literal> 元素允许你映射一个组件类作为一个 <literal>Map</literal> 的 key，前提是你必须正确的在这个类中重写了 <literal>hashCode()</literal> 和 <literal>equals()</literal> 方法。 "
#. Tag: title
#, no-c-format
@ -246,11 +126,8 @@ msgstr "组件作为联合标识符（Components as composite identifiers）"
#. Tag: para
#, no-c-format
msgid ""
"You can use a component as an identifier of an entity class. Your component "
"class must satisfy certain requirements:"
msgstr ""
"你可以使用一个组件作为一个实体类的标识符。你的组件类必须满足以下要求： "
msgid "You can use a component as an identifier of an entity class. Your component class must satisfy certain requirements:"
msgstr "你可以使用一个组件作为一个实体类的标识符。你的组件类必须满足以下要求： "
#. Tag: para
#, no-c-format
@ -259,12 +136,8 @@ msgstr "它必须实现 <literal>java.io.Serializable</literal> 接口"
#. Tag: para
#, no-c-format
msgid ""
"It must re-implement <literal>equals()</literal> and <literal>hashCode()</"
"literal> consistently with the database's notion of composite key equality."
msgstr ""
"它必须重新实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> "
"方法，始终和组合关键字在数据库中的概念保持一致 "
msgid "It must re-implement <literal>equals()</literal> and <literal>hashCode()</literal> consistently with the database's notion of composite key equality."
msgstr "它必须重新实现 <literal>equals()</literal> 和 <literal>hashCode()</literal> 方法，始终和组合关键字在数据库中的概念保持一致 "
#. Tag: title
#, no-c-format
@ -273,75 +146,38 @@ msgstr "注意"
#. Tag: para
#, no-c-format
msgid ""
"In Hibernate3, although the second requirement is not an absolutely hard "
"requirement of Hibernate, it is recommended."
msgstr ""
"注意：在 Hibernate3 中，第二个要求并非是 Hibernate 强制必须的。但最好这样"
"做。 "
msgid "In Hibernate3, although the second requirement is not an absolutely hard requirement of Hibernate, it is recommended."
msgstr "注意：在 Hibernate3 中，第二个要求并非是 Hibernate 强制必须的。但最好这样做。 "
#. Tag: para
#, no-c-format
msgid ""
"You cannot use an <literal>IdentifierGenerator</literal> to generate "
"composite keys. Instead the application must assign its own identifiers."
msgstr ""
"你不能使用一个 <literal>IdentifierGenerator</literal> 产生组合关键字。一个应"
"用程序必须分配它自己的标识符。 "
msgid "You cannot use an <literal>IdentifierGenerator</literal> to generate composite keys. Instead the application must assign its own identifiers."
msgstr "你不能使用一个 <literal>IdentifierGenerator</literal> 产生组合关键字。一个应用程序必须分配它自己的标识符。 "
#. Tag: para
#, no-c-format
msgid ""
"Use the <literal>&lt;composite-id&gt;</literal> tag, with nested "
"<literal>&lt;key-property&gt;</literal> elements, in place of the usual "
"<literal>&lt;id&gt;</literal> declaration. For example, the "
"<literal>OrderLine</literal> class has a primary key that depends upon the "
"(composite) primary key of <literal>Order</literal>."
msgstr ""
"使用 <literal>&lt;composite-id&gt;</literal> 标签（并且内嵌 <literal>&lt;key-"
"property&gt;</literal> 元素）代替通常的 <literal>&lt;id&gt;</literal> 标签。"
"比如，<literal>OrderLine</literal> 类具有一个主键，这个主键依赖于 "
"<literal>Order</literal> 的（联合）主键。 "
msgid "Use the <literal>&lt;composite-id&gt;</literal> tag, with nested <literal>&lt;key-property&gt;</literal> elements, in place of the usual <literal>&lt;id&gt;</literal> declaration. For example, the <literal>OrderLine</literal> class has a primary key that depends upon the (composite) primary key of <literal>Order</literal>."
msgstr "使用 <literal>&lt;composite-id&gt;</literal> 标签（并且内嵌 <literal>&lt;key-property&gt;</literal> 元素）代替通常的 <literal>&lt;id&gt;</literal> 标签。比如，<literal>OrderLine</literal> 类具有一个主键，这个主键依赖于 <literal>Order</literal> 的（联合）主键。 "
#. Tag: para
#, no-c-format
msgid ""
"Any foreign keys referencing the <literal>OrderLine</literal> table are now "
"composite. Declare this in your mappings for other classes. An association "
"to <literal>OrderLine</literal> is mapped like this:"
msgstr ""
"现在，任何指向 <literal>OrderLine</literal> 的外键都是复合的。在你的映射文件"
"中，必须为其他类也这样声明。例如，一个指向 <literal>OrderLine</literal> 的关"
"联可能被这样映射： "
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The <literal>column</literal> element is an alternative to the "
"<literal>column</literal> attribute everywhere. Using the <literal>column</"
"literal> element just gives more declaration options, which are mostly "
"useful when utilizing <literal>hbm2ddl</literal>"
msgstr ""
"（注意在各个地方 <literal>&lt;column&gt;</literal> 标签都是 <literal>column</"
"literal> 属性的替代写法。） "
msgid "Any foreign keys referencing the <literal>OrderLine</literal> table are now composite. Declare this in your mappings for other classes. An association to <literal>OrderLine</literal> is mapped like this:"
msgstr "现在，任何指向 <literal>OrderLine</literal> 的外键都是复合的。在你的映射文件中，必须为其他类也这样声明。例如，一个指向 <literal>OrderLine</literal> 的关联可能被这样映射： "
#. Tag: para
#, no-c-format
msgid ""
"A <literal>many-to-many</literal> association to <literal>OrderLine</"
"literal> also uses the composite foreign key:"
msgstr ""
"指向 <literal>OrderLine</literal> 的<literal>多对多</literal>关联也使用联合外"
"键："
msgid "The <literal>column</literal> element is an alternative to the <literal>column</literal> attribute everywhere. Using the <literal>column</literal> element just gives more declaration options, which are mostly useful when utilizing <literal>hbm2ddl</literal>"
msgstr "注意在各个地方 <literal>column</literal> 标签都是 <literal>column</literal> 属性的替代写法。使用 <literal>column</literal> 元素只是给出一个更详细的选项，在使用 <literal>hbm2ddl</literal> 时会更有用。"
#. Tag: para
#, no-c-format
msgid ""
"The collection of <literal>OrderLine</literal>s in <literal>Order</literal> "
"would use:"
msgstr ""
"在 <literal>Order</literal> 中，<literal>OrderLine</literal> 的集合则是这"
"样： "
msgid "A <literal>many-to-many</literal> association to <literal>OrderLine</literal> also uses the composite foreign key:"
msgstr "指向 <literal>OrderLine</literal> 的<literal>多对多</literal>关联也使用联合外键："
#. Tag: para
#, no-c-format
msgid "The collection of <literal>OrderLine</literal>s in <literal>Order</literal> would use:"
msgstr "在 <literal>Order</literal> 中，<literal>OrderLine</literal> 的集合则是这样： "
#. Tag: para
#, no-c-format
@ -350,9 +186,7 @@ msgstr "与通常一样，<literal>&lt;one-to-many&gt;</literal> 元素不声明
#. Tag: para
#, no-c-format
msgid ""
"If <literal>OrderLine</literal> itself owns a collection, it also has a "
"composite foreign key."
msgid "If <literal>OrderLine</literal> itself owns a collection, it also has a composite foreign key."
msgstr "假若 <literal>OrderLine</literal> 本身拥有一个集合，它也具有组合外键。"
#. Tag: title
@ -367,20 +201,8 @@ msgstr "你甚至可以映射 <literal>Map</literal> 类型的属性： "
#. Tag: para
#, no-c-format
msgid ""
"The semantics of a <literal>&lt;dynamic-component&gt;</literal> mapping are "
"identical to <literal>&lt;component&gt;</literal>. The advantage of this "
"kind of mapping is the ability to determine the actual properties of the "
"bean at deployment time just by editing the mapping document. Runtime "
"manipulation of the mapping document is also possible, using a DOM parser. "
"You can also access, and change, Hibernate's configuration-time metamodel "
"via the <literal>Configuration</literal> object."
msgstr ""
"从 <literal>&lt;dynamic-component&gt;</literal> 映射的语义上来讲，它和 "
"<literal>&lt;component&gt;</literal> 是相同的。这种映射类型的优点在于通过修改"
"映射文件，就可以具有在部署时检测真实属性的能力。利用一个 DOM 解析器，也可以在"
"程序运行时操作映射文件。更好的是，你可以通过 <literal>Configuration</"
"literal> 对象来访问（或者修改）Hibernate 的运行时元模型。 "
msgid "The semantics of a <literal>&lt;dynamic-component&gt;</literal> mapping are identical to <literal>&lt;component&gt;</literal>. The advantage of this kind of mapping is the ability to determine the actual properties of the bean at deployment time just by editing the mapping document. Runtime manipulation of the mapping document is also possible, using a DOM parser. You can also access, and change, Hibernate's configuration-time metamodel via the <literal>Configuration</literal> object."
msgstr "从 <literal>&lt;dynamic-component&gt;</literal> 映射的语义上来讲，它和 <literal>&lt;component&gt;</literal> 是相同的。这种映射类型的优点在于通过修改映射文件，就可以具有在部署时检测真实属性的能力。利用一个 DOM 解析器，也可以在程序运行时操作映射文件。更好的是，你可以通过 <literal>Configuration</literal> 对象来访问（或者修改）Hibernate 的运行时元模型。 "
#~ msgid ""
#~ "<![CDATA[public class Person {\n"

1443
documentation/manual/src/main/docbook/zh-CN/content/configuration.po
View File

File diff suppressed because it is too large Load Diff

320
documentation/manual/src/main/docbook/zh-CN/content/inheritance_mapping.po
View File

@ -6,7 +6,7 @@ msgstr ""
"Project-Id-Version: Collection_Mapping\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-11T05:38:15\n"
"PO-Revision-Date: 2009-12-07 09:35+1000\n"
"PO-Revision-Date: 2010-03-15 09:06+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Language-Team: <en@li.org>\n"
"MIME-Version: 1.0\n"
@ -46,9 +46,7 @@ msgstr "每个具体类一张表（table per concrete class）"
#. Tag: para
#, no-c-format
msgid ""
"In addition, Hibernate supports a fourth, slightly different kind of "
"polymorphism:"
msgid "In addition, Hibernate supports a fourth, slightly different kind of polymorphism:"
msgstr "此外，Hibernate 还支持第四种稍有不同的多态映射策略："
#. Tag: para
@ -58,48 +56,13 @@ msgstr "隐式多态（implicit polymorphism）"
#. Tag: para
#, no-c-format
msgid ""
"It is possible to use different mapping strategies for different branches of "
"the same inheritance hierarchy. You can then make use of implicit "
"polymorphism to achieve polymorphism across the whole hierarchy. However, "
"Hibernate does not support mixing <literal>&lt;subclass&gt;</literal>, "
"<literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-"
"subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</"
"literal> element. It is possible to mix together the table per hierarchy and "
"table per subclass strategies under the the same <literal>&lt;class&gt;</"
"literal> element, by combining the <literal>&lt;subclass&gt;</literal> and "
"<literal>&lt;join&gt;</literal> elements (see below for an example)."
msgstr ""
"对于同一个继承层次内的不同分支，可以采用不同的映射策略，然后用隐式多 态来完成"
"跨越整个层次的多态。但是在同一个 <literal>&lt;class&gt;</literal> 根元素下，"
"Hibernate 不支持混合了元素 <literal>&lt;subclass&gt;</literal>、<literal>&lt;"
"joined-subclass&gt;</literal> 和 <literal>&lt;union-subclass&gt;</literal> 的"
"映射。在同一个 <literal>&lt;class&gt;</literal> 元素下，可以混合使用“每个类分"
"层结构一张表”（table per hierarchy）和“每个子类一张表”（table per subclass） "
"这两种映射策略，这是通过结合元素 <literal>&lt;subclass&gt;</literal> 和 "
"<literal>&lt;join&gt;</literal> 来实现的（见后）。 "
msgid "It is possible to use different mapping strategies for different branches of the same inheritance hierarchy. You can then make use of implicit polymorphism to achieve polymorphism across the whole hierarchy. However, Hibernate does not support mixing <literal>&lt;subclass&gt;</literal>, <literal>&lt;joined-subclass&gt;</literal> and <literal>&lt;union-subclass&gt;</literal> mappings under the same root <literal>&lt;class&gt;</literal> element. It is possible to mix together the table per hierarchy and table per subclass strategies under the the same <literal>&lt;class&gt;</literal> element, by combining the <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal> elements (see below for an example)."
msgstr "对于同一个继承层次内的不同分支，可以采用不同的映射策略，然后用隐式多 态来完成跨越整个层次的多态。但是在同一个 <literal>&lt;class&gt;</literal> 根元素下，Hibernate 不支持混合了元素 <literal>&lt;subclass&gt;</literal>、<literal>&lt;joined-subclass&gt;</literal> 和 <literal>&lt;union-subclass&gt;</literal> 的映射。在同一个 <literal>&lt;class&gt;</literal> 元素下，可以混合使用“每个类分层结构一张表”（table per hierarchy）和“每个子类一张表”（table per subclass） 这两种映射策略，这是通过结合元素 <literal>&lt;subclass&gt;</literal> 和 <literal>&lt;join&gt;</literal> 来实现的（见后）。 "
#. Tag: para
#, no-c-format
msgid ""
"It is possible to define <literal>subclass</literal>, <literal>union-"
"subclass</literal>, and <literal>joined-subclass</literal> mappings in "
"separate mapping documents directly beneath <literal>hibernate-mapping</"
"literal>. This allows you to extend a class hierarchy by adding a new "
"mapping file. You must specify an <literal>extends</literal> attribute in "
"the subclass mapping, naming a previously mapped superclass. Previously this "
"feature made the ordering of the mapping documents important. Since "
"Hibernate3, the ordering of mapping files is irrelevant when using the "
"extends keyword. The ordering inside a single mapping file still needs to be "
"defined as superclasses before subclasses."
msgstr ""
"在多个映射文件中，可以直接在 <literal>hibernate-mapping</literal> 根下定义 "
"<literal>subclass</literal>，<literal>union-subclass</literal> 和 "
"<literal>joined-subclass</literal>。也就是说，你可以仅加入一个新的映射文件来"
"扩展类层次。你必须在 subclass 的映射中指明 <literal>extends</literal> 属性，"
"给出一个之前定义的超类的名字。注意，在以前，这一功能对映射文件的顺序有严格的"
"要求，从 Hibernate 3 开始，使用 extends 关键字的时侯，对映射文件的顺序不再有"
"要求；但在每个映射文件里，超类必须在子类之前定义。 "
msgid "It is possible to define <literal>subclass</literal>, <literal>union-subclass</literal>, and <literal>joined-subclass</literal> mappings in separate mapping documents directly beneath <literal>hibernate-mapping</literal>. This allows you to extend a class hierarchy by adding a new mapping file. You must specify an <literal>extends</literal> attribute in the subclass mapping, naming a previously mapped superclass. Previously this feature made the ordering of the mapping documents important. Since Hibernate3, the ordering of mapping files is irrelevant when using the extends keyword. The ordering inside a single mapping file still needs to be defined as superclasses before subclasses."
msgstr "在多个映射文件中，可以直接在 <literal>hibernate-mapping</literal> 根下定义 <literal>subclass</literal>，<literal>union-subclass</literal> 和 <literal>joined-subclass</literal>。也就是说，你可以仅加入一个新的映射文件来扩展类层次。你必须在 subclass 的映射中指明 <literal>extends</literal> 属性，给出一个之前定义的超类的名字。注意，在以前，这一功能对映射文件的顺序有严格的要求，从 Hibernate 3 开始，使用 extends 关键字的时侯，对映射文件的顺序不再有要求；但在每个映射文件里，超类必须在子类之前定义。 "
#. Tag: title
#, no-c-format
@ -108,27 +71,13 @@ msgstr "每个类分层结构一张表（Table per class hierarchy）"
#. Tag: para
#, no-c-format
msgid ""
"Suppose we have an interface <literal>Payment</literal> with the "
"implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</"
"literal>, and <literal>ChequePayment</literal>. The table per hierarchy "
"mapping would display in the following way:"
msgstr ""
"假设我们有接口<literal>Payment</literal>和它的几个实现类： "
"<literal>CreditCardPayment</literal>, <literal>CashPayment</literal> 和"
"<literal>ChequePayment</literal>。则“每个类分层结构一张表”（Table per class "
"hierarchy）的映射代码如下所示： "
msgid "Suppose we have an interface <literal>Payment</literal> with the implementors <literal>CreditCardPayment</literal>, <literal>CashPayment</literal>, and <literal>ChequePayment</literal>. The table per hierarchy mapping would display in the following way:"
msgstr "假设我们有接口<literal>Payment</literal>和它的几个实现类： <literal>CreditCardPayment</literal>, <literal>CashPayment</literal> 和<literal>ChequePayment</literal>。则“每个类分层结构一张表”（Table per class hierarchy）的映射代码如下所示： "
#. Tag: para
#, no-c-format
msgid ""
"Exactly one table is required. There is a limitation of this mapping "
"strategy: columns declared by the subclasses, such as <literal>CCTYPE</"
"literal>, cannot have <literal>NOT NULL</literal> constraints."
msgstr ""
"采用这种策略只需要一张表即可。它有一个很大的限制：要求那些由子类定义的字段， "
"如 <literal>CCTYPE</literal>，不能有<literal>非空（NOT NULL）</literal>约"
"束。 "
msgid "Exactly one table is required. There is a limitation of this mapping strategy: columns declared by the subclasses, such as <literal>CCTYPE</literal>, cannot have <literal>NOT NULL</literal> constraints."
msgstr "采用这种策略只需要一张表即可。它有一个很大的限制：要求那些由子类定义的字段， 如 <literal>CCTYPE</literal>，不能有<literal>非空（NOT NULL）</literal>约束。 "
#. Tag: title
#, no-c-format
@ -138,18 +87,12 @@ msgstr "每个子类一张表（Table per subclass）"
#. Tag: para
#, no-c-format
msgid "A table per subclass mapping looks like this:"
msgstr ""
" 对于上例中的几个类而言，采用“每个子类一张表”的映射策略，代码如下所示："
msgstr " 对于上例中的几个类而言，采用“每个子类一张表”的映射策略，代码如下所示："
#. Tag: para
#, no-c-format
msgid ""
"Four tables are required. The three subclass tables have primary key "
"associations to the superclass table so the relational model is actually a "
"one-to-one association."
msgstr ""
"需要四张表。三个子类表通过主键关联到超类表（因而关系模型实际上是一对一关"
"联）。 "
msgid "Four tables are required. The three subclass tables have primary key associations to the superclass table so the relational model is actually a one-to-one association."
msgstr "需要四张表。三个子类表通过主键关联到超类表（因而关系模型实际上是一对一关联）。 "
#. Tag: title
#, no-c-format
@ -158,33 +101,13 @@ msgstr "每个子类一张表（Table per subclass），使用辨别标志（Dis
#. Tag: para
#, no-c-format
msgid ""
"Hibernate's implementation of table per subclass does not require a "
"discriminator column. Other object/relational mappers use a different "
"implementation of table per subclass that requires a type discriminator "
"column in the superclass table. The approach taken by Hibernate is much more "
"difficult to implement, but arguably more correct from a relational point of "
"view. If you want to use a discriminator column with the table per subclass "
"strategy, you can combine the use of <literal>&lt;subclass&gt;</literal> and "
"<literal>&lt;join&gt;</literal>, as follows:"
msgstr ""
"注意，对“每个子类一张表”的映射策略，Hibernate 的实现不需要辨别字段，而其他的"
"对象／关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类表中有"
"一个类型辨别字段（type discriminator column）。Hibernate 采用的方法更难实现，"
"但从关系（数据库）的角度来看，按理说它更正确。若你愿意使用带有辨别字段的“每个"
"子类一张表”的策略，你可以结合使用 <literal>&lt;subclass&gt;</literal> 与"
"<literal>&lt;join&gt;</literal>，如下所示： "
msgid "Hibernate's implementation of table per subclass does not require a discriminator column. Other object/relational mappers use a different implementation of table per subclass that requires a type discriminator column in the superclass table. The approach taken by Hibernate is much more difficult to implement, but arguably more correct from a relational point of view. If you want to use a discriminator column with the table per subclass strategy, you can combine the use of <literal>&lt;subclass&gt;</literal> and <literal>&lt;join&gt;</literal>, as follows:"
msgstr "注意，对“每个子类一张表”的映射策略，Hibernate 的实现不需要辨别字段，而其他的对象／关系映射工具使用了一种不同于Hibernate的实现方法，该方法要求在超类表中有一个类型辨别字段（type discriminator column）。Hibernate 采用的方法更难实现，但从关系（数据库）的角度来看，按理说它更正确。若你愿意使用带有辨别字段的“每个子类一张表”的策略，你可以结合使用 <literal>&lt;subclass&gt;</literal> 与<literal>&lt;join&gt;</literal>，如下所示： "
#. Tag: para
#, no-c-format
msgid ""
"The optional <literal>fetch=\"select\"</literal> declaration tells Hibernate "
"not to fetch the <literal>ChequePayment</literal> subclass data using an "
"outer join when querying the superclass."
msgstr ""
"可选的声明 <literal>fetch=\"select\"</literal>，是用来告诉 Hibernate，在查询"
"超类时，不要使用外部连接（outer join）来抓取子类 <literal>ChequePayment</"
"literal> 的数据。"
msgid "The optional <literal>fetch=\"select\"</literal> declaration tells Hibernate not to fetch the <literal>ChequePayment</literal> subclass data using an outer join when querying the superclass."
msgstr "可选的声明 <literal>fetch=\"select\"</literal>，是用来告诉 Hibernate，在查询超类时，不要使用外部连接（outer join）来抓取子类 <literal>ChequePayment</literal> 的数据。"
#. Tag: title
#, no-c-format
@ -193,22 +116,13 @@ msgstr "混合使用“每个类分层结构一张表”和“每个子类一张
#. Tag: para
#, no-c-format
msgid ""
"You can even mix the table per hierarchy and table per subclass strategies "
"using the following approach:"
msgstr ""
"你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种"
"策略： "
msgid "You can even mix the table per hierarchy and table per subclass strategies using the following approach:"
msgstr "你甚至可以采取如下方法混和使用“每个类分层结构一张表”和“每个子类一张表”这两种策略： "
#. Tag: para
#, no-c-format
msgid ""
"For any of these mapping strategies, a polymorphic association to the root "
"<literal>Payment</literal> class is mapped using <literal>&lt;many-to-one&gt;"
"</literal>."
msgstr ""
"对上述任何一种映射策略而言，指向根类 <literal>Payment</literal> 的关联是使用 "
"<literal>&lt;many-to-one&gt;</literal> 进行映射的。"
msgid "For any of these mapping strategies, a polymorphic association to the root <literal>Payment</literal> class is mapped using <literal>&lt;many-to-one&gt;</literal>."
msgstr "对上述任何一种映射策略而言，指向根类 <literal>Payment</literal> 的关联是使用 <literal>&lt;many-to-one&gt;</literal> 进行映射的。"
#. Tag: title
#, no-c-format
@ -217,48 +131,23 @@ msgstr "每个具体类一张表（Table per concrete class）"
#. Tag: para
#, no-c-format
msgid ""
"There are two ways we can map the table per concrete class strategy. First, "
"you can use <literal>&lt;union-subclass&gt;</literal>."
msgstr ""
"对于“每个具体类一张表”的映射策略，可以采用两种方法。第一种方法是使用 "
"<literal>&lt;union-subclass&gt;</literal>。 "
msgid "There are two ways we can map the table per concrete class strategy. First, you can use <literal>&lt;union-subclass&gt;</literal>."
msgstr "对于“每个具体类一张表”的映射策略，可以采用两种方法。第一种方法是使用 <literal>&lt;union-subclass&gt;</literal>。 "
#. Tag: para
#, no-c-format
msgid ""
"Three tables are involved for the subclasses. Each table defines columns for "
"all properties of the class, including inherited properties."
msgstr ""
"这里涉及三张与子类相关的表。每张表为对应类的所有属性（包括从超类继承的属性）"
"定义相应字段。"
msgid "Three tables are involved for the subclasses. Each table defines columns for all properties of the class, including inherited properties."
msgstr "这里涉及三张与子类相关的表。每张表为对应类的所有属性（包括从超类继承的属性）定义相应字段。"
#. Tag: para
#, no-c-format
msgid ""
"The limitation of this approach is that if a property is mapped on the "
"superclass, the column name must be the same on all subclass tables. The "
"identity generator strategy is not allowed in union subclass inheritance. "
"The primary key seed has to be shared across all unioned subclasses of a "
"hierarchy."
msgstr ""
"这种方式的局限在于，如果一个属性在超类中做了映射，其字段名必须与所有子类表中"
"定义的相同。（我们可能会在 Hibernate 的后续发布版本中放宽此限制。）不允许在联"
"合子类（union subclass）的继承层次中使用标识生成器策略（identity generator "
"strategy），实际上，主键的种子（primary key seed）不得不为同一继承层次中的全"
"部被联合子类所共用。 "
msgid "The limitation of this approach is that if a property is mapped on the superclass, the column name must be the same on all subclass tables. The identity generator strategy is not allowed in union subclass inheritance. The primary key seed has to be shared across all unioned subclasses of a hierarchy."
msgstr "这种方式的局限在于，如果一个属性在超类中做了映射，其字段名必须与所有子类表中定义的相同。（我们可能会在 Hibernate 的后续发布版本中放宽此限制。）不允许在联合子类（union subclass）的继承层次中使用标识生成器策略（identity generator strategy），实际上，主键的种子（primary key seed）不得不为同一继承层次中的全部被联合子类所共用。 "
#. Tag: para
#, no-c-format
msgid ""
"If your superclass is abstract, map it with <literal>abstract=\"true\"</"
"literal>. If it is not abstract, an additional table (it defaults to "
"<literal>PAYMENT</literal> in the example above), is needed to hold "
"instances of the superclass."
msgstr ""
"假若超类是抽象类，请使用 <literal>abstract=\"true\"</literal>。当然，假若它不"
"是抽象的，需要一个额外的表（上面的例子中，默认是 <literal>PAYMENT</"
"literal>），来保存超类的实例。 "
msgid "If your superclass is abstract, map it with <literal>abstract=\"true\"</literal>. If it is not abstract, an additional table (it defaults to <literal>PAYMENT</literal> in the example above), is needed to hold instances of the superclass."
msgstr "假若超类是抽象类，请使用 <literal>abstract=\"true\"</literal>。当然，假若它不是抽象的，需要一个额外的表（上面的例子中，默认是 <literal>PAYMENT</literal>），来保存超类的实例。 "
#. Tag: title
#, no-c-format
@ -271,38 +160,19 @@ msgid "An alternative approach is to make use of implicit polymorphism:"
msgstr "另一种可供选择的方法是采用隐式多态："
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Notice that the <literal>Payment</literal> interface is not mentioned "
"explicitly. Also notice that properties of <literal>Payment</literal> are "
"mapped in each of the subclasses. If you want to avoid duplication, consider "
"using XML entities (for example, <literal>[ &lt;!ENTITY allproperties SYSTEM "
"\"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> "
"declaration and <literal>&amp;allproperties&semi;</literal> in the mapping)."
msgstr ""
"请注意这里没有显性地提及 <literal>Payment</literal> 接口。<literal>Payment</"
"literal> 的属性映射到每个子类。如果你想避免重复，请考虑使用 XML 实体（如："
"<literal>DOCTYPE</literal> 声明里的 <literal>[ &lt;!ENTITY allproperties "
"SYSTEM \"allproperties.xml\"&gt; ]</literal> 和映射里的 <literal>&amp;"
"allproperties&semi;</literal>）。"
#, no-c-format
msgid "Notice that the <literal>Payment</literal> interface is not mentioned explicitly. Also notice that properties of <literal>Payment</literal> are mapped in each of the subclasses. If you want to avoid duplication, consider using XML entities (for example, <literal>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> in the <literal>DOCTYPE</literal> declaration and <literal>&amp;allproperties&semi;</literal> in the mapping)."
msgstr "请注意，这里没有显性地提及 <literal>Payment</literal> 接口。<literal>Payment</literal> 的属性映射到每个子类。如果你想避免重复，请考虑使用 XML 实体（如：<literal>DOCTYPE</literal> 声明里的 <literal>[ &lt;!ENTITY allproperties SYSTEM \"allproperties.xml\"&gt; ]</literal> 和映射里的 <literal>&amp;allproperties&semi;</literal>）。 "
#. Tag: para
#, no-c-format
msgid ""
"The disadvantage of this approach is that Hibernate does not generate SQL "
"<literal>UNION</literal>s when performing polymorphic queries."
msgstr ""
"这种方法的缺陷在于，在 Hibernate 执行多态查询时（polymorphic queries）无法生"
"成带 <literal>UNION</literal> 的 SQL 语句。 "
msgid "The disadvantage of this approach is that Hibernate does not generate SQL <literal>UNION</literal>s when performing polymorphic queries."
msgstr "这种方法的缺陷在于，在 Hibernate 执行多态查询时（polymorphic queries）无法生成带 <literal>UNION</literal> 的 SQL 语句。 "
#. Tag: para
#, no-c-format
msgid ""
"For this mapping strategy, a polymorphic association to <literal>Payment</"
"literal> is usually mapped using <literal>&lt;any&gt;</literal>."
msgstr ""
"对于这种映射策略而言，通常用 <literal>&lt;any&gt;</literal> 来实现到 "
"<literal>Payment</literal> 的多态关联映射。"
msgid "For this mapping strategy, a polymorphic association to <literal>Payment</literal> is usually mapped using <literal>&lt;any&gt;</literal>."
msgstr "对于这种映射策略而言，通常用 <literal>&lt;any&gt;</literal> 来实现到 <literal>Payment</literal> 的多态关联映射。"
#. Tag: title
#, no-c-format
@ -311,35 +181,13 @@ msgstr "隐式多态和其他继承映射混合使用"
#. Tag: para
#, no-c-format
msgid ""
"Since the subclasses are each mapped in their own <literal>&lt;class&gt;</"
"literal> element, and since <literal>Payment</literal> is just an "
"interface), each of the subclasses could easily be part of another "
"inheritance hierarchy. You can still use polymorphic queries against the "
"<literal>Payment</literal> interface."
msgstr ""
"对这一映射还有一点需要注意。因为每个子类都在各自独立的元素 <literal>&lt;"
"class&gt;</literal> 中映射（并且 <literal>Payment</literal> 只是一个接口），"
"每个子类可以很容易的成为另一个继承体系中的一部分！（你仍然可以对接口 "
"<literal>Payment</literal> 使用多态查询。） "
msgid "Since the subclasses are each mapped in their own <literal>&lt;class&gt;</literal> element, and since <literal>Payment</literal> is just an interface), each of the subclasses could easily be part of another inheritance hierarchy. You can still use polymorphic queries against the <literal>Payment</literal> interface."
msgstr "对这一映射还有一点需要注意。因为每个子类都在各自独立的元素 <literal>&lt;class&gt;</literal> 中映射（并且 <literal>Payment</literal> 只是一个接口），每个子类可以很容易的成为另一个继承体系中的一部分！（你仍然可以对接口 <literal>Payment</literal> 使用多态查询。） "
#. Tag: para
#, no-c-format
msgid ""
"Once again, <literal>Payment</literal> is not mentioned explicitly. If we "
"execute a query against the <literal>Payment</literal> interface, for "
"example <literal>from Payment</literal>, Hibernate automatically returns "
"instances of <literal>CreditCardPayment</literal> (and its subclasses, since "
"they also implement <literal>Payment</literal>), <literal>CashPayment</"
"literal> and <literal>ChequePayment</literal>, but not instances of "
"<literal>NonelectronicTransaction</literal>."
msgstr ""
"我们还是没有明确的提到 <literal>Payment</literal>。如果我们针对接口 "
"<literal>Payment</literal> 执行查询 — 如 <literal>from Payment</literal> — "
"Hibernate 自动返回 <literal>CreditCardPayment</literal>（和它的子类，因为 它"
"们也实现了接口 <literal>Payment</literal>）、<literal>CashPayment</literal> "
"和 <literal>Chequepayment</literal> 的实例，但不返回 "
"<literal>NonelectronicTransaction</literal> 的实例。 "
msgid "Once again, <literal>Payment</literal> is not mentioned explicitly. If we execute a query against the <literal>Payment</literal> interface, for example <literal>from Payment</literal>, Hibernate automatically returns instances of <literal>CreditCardPayment</literal> (and its subclasses, since they also implement <literal>Payment</literal>), <literal>CashPayment</literal> and <literal>ChequePayment</literal>, but not instances of <literal>NonelectronicTransaction</literal>."
msgstr "我们还是没有明确的提到 <literal>Payment</literal>。如果我们针对接口 <literal>Payment</literal> 执行查询 — 如 <literal>from Payment</literal> — Hibernate 自动返回 <literal>CreditCardPayment</literal>（和它的子类，因为 它们也实现了接口 <literal>Payment</literal>）、<literal>CashPayment</literal> 和 <literal>Chequepayment</literal> 的实例，但不返回 <literal>NonelectronicTransaction</literal> 的实例。 "
#. Tag: title
#, no-c-format
@ -348,22 +196,13 @@ msgstr "限制"
#. Tag: para
#, no-c-format
msgid ""
"There are limitations to the \"implicit polymorphism\" approach to the table "
"per concrete-class mapping strategy. There are somewhat less restrictive "
"limitations to <literal>&lt;union-subclass&gt;</literal> mappings."
msgstr ""
"对“每个具体类映射一张表”（table per concrete-class）的映射策略而言，隐式多态"
"的方式有一定的限制。而 <literal>&lt;union-subclass&gt;</literal> 映射的限制则"
"没有那么严格。 "
msgid "There are limitations to the \"implicit polymorphism\" approach to the table per concrete-class mapping strategy. There are somewhat less restrictive limitations to <literal>&lt;union-subclass&gt;</literal> mappings."
msgstr "对“每个具体类映射一张表”（table per concrete-class）的映射策略而言，隐式多态的方式有一定的限制。而 <literal>&lt;union-subclass&gt;</literal> 映射的限制则没有那么严格。 "
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"The following table shows the limitations of table per concrete-class "
"mappings, and of implicit polymorphism, in Hibernate."
msgstr ""
"下面表格中列出了在 Hibernte 中“每个具体类一张表”的策略和隐式多态的限制。 "
#, no-c-format
msgid "The following table shows the limitations of table per concrete-class mappings, and of implicit polymorphism, in Hibernate."
msgstr "下面表格中列出了在 Hibernte 中“每个具体类一张表”的策略和隐式多态的限制。"
#. Tag: title
#, no-c-format
@ -376,7 +215,7 @@ msgid "Inheritance strategy"
msgstr "继承策略（Inheritance strategy）"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "Polymorphic many-to-one"
msgstr "多态多对多 "
@ -411,54 +250,54 @@ msgid "Polymorphic joins"
msgstr "多态连接（join）"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "Outer join fetching"
msgstr "支持外连接（Outer join）读取。 "
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "table per class-hierarchy"
msgstr "每个类分层结构一张表（table per class hierarchy） "
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>&lt;many-to-one&gt;</literal>"
msgstr "&lt;many-to-one&gt;"
msgstr "<literal>&lt;many-to-one&gt;</literal>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>&lt;one-to-one&gt;</literal>"
msgstr "&lt;one-to-one&gt;"
msgstr "<literal>&lt;one-to-one&gt;</literal>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>&lt;one-to-many&gt;</literal>"
msgstr "&lt;one-to-many&gt;"
msgstr "<literal>&lt;one-to-many&gt;</literal>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>&lt;many-to-many&gt;</literal>"
msgstr "&lt;many-to-many&gt;"
msgstr "<literal>&lt;many-to-many&gt;</literal>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>s.get(Payment.class, id)</literal>"
msgstr "s.get(Payment.class, id)"
msgstr "<literal>s.get(Payment.class, id)</literal>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>from Payment p</literal>"
msgstr "Polymorphic <literal>load()/get()</literal>"
msgstr "<literal>from Payment p</literal>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>from Order o join o.payment p</literal>"
msgstr "多态性 join：<code>from Order o join o.payment p</code>"
msgstr "<literal>from Order o join o.payment p</literal>"
#. Tag: entry
#, no-c-format
msgid "<emphasis>supported</emphasis>"
msgstr ""
msgstr "<emphasis>所支持的</emphasis>"
#. Tag: entry
#, no-c-format
@ -466,43 +305,34 @@ msgid "table per concrete-class (union-subclass)"
msgstr "每个具体类一张表（union-subclass）"
#. Tag: entry
#, fuzzy, no-c-format
msgid ""
"<literal>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</"
"literal> only)"
msgstr ""
"多态性一对多：<literal>&lt;one-to-many&gt;</literal> (仅适用于 "
"<literal>inverse=\"true\"</literal>)"
#, no-c-format
msgid "<literal>&lt;one-to-many&gt;</literal> (for <literal>inverse=\"true\"</literal> only)"
msgstr "<literal>&lt;one-to-many&gt;</literal> (仅适用于 <literal>inverse=\"true\"</literal>)"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "table per concrete class (implicit polymorphism)"
msgstr "每个具体类一张表（隐式多态） "
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>&lt;any&gt;</literal>"
msgstr "Polymorphic <literal>load()/get()</literal>"
msgstr "<literal>&lt;any&gt;</literal>"
#. Tag: entry
#, no-c-format
msgid "<emphasis>not supported</emphasis>"
msgstr ""
msgstr "<emphasis>不支持的</emphasis>"
#. Tag: entry
#, fuzzy, no-c-format
#, no-c-format
msgid "<literal>&lt;many-to-any&gt;</literal>"
msgstr "&lt;many-to-any&gt;"
msgstr "<literal>&lt;many-to-any&gt;</literal>"
#. Tag: entry
#, fuzzy, no-c-format
msgid ""
"<literal>s.createCriteria(Payment.class).add( Restrictions.idEq(id) )."
"uniqueResult()</literal>"
msgstr ""
"多态性 <literal>load()</literal> 或 <literal>get()</literal>：<code>s."
"createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()</"
"code>"
#, no-c-format
msgid "<literal>s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()</literal>"
msgstr "<literal>s.createCriteria(Payment.class).add( Restrictions.idEq(id) ).uniqueResult()</literal>"
#~ msgid "table per class-heirarchy"
#~ msgstr "每个类分层结构一张表 "

1495
documentation/manual/src/main/docbook/zh-CN/content/performance.po
View File

File diff suppressed because it is too large Load Diff

62
documentation/manual/src/main/docbook/zh-CN/legal_notice.po
View File

@ -1,11 +1,14 @@
#, fuzzy
msgid ""
msgstr ""
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2010-02-04T04:51:23\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"PO-Revision-Date: 2010-03-15 08:45+1000\n"
"Last-Translator: Xi HUANG <xhuang@redhat.com>\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Project-Id-Version: \n"
"Language-Team: \n"
"MIME-Version: 1.0\n"
"Content-Transfer-Encoding: 8bit\n"
#. Tag: title
#, no-c-format
@ -13,53 +16,24 @@ msgid "Legal Notice"
msgstr "Legal Notice"
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"<address> <street>1801 Varsity Drive</street> <city>Raleigh</city>, "
"<state>NC</state><postcode>27606-2072</postcode><country>USA</country> "
"<phone>Phone: +1 919 754 3700</phone> <phone>Phone: 888 733 4281</phone> "
"<fax>Fax: +1 919 754 3701</fax> <pob>PO Box 13588</pob><city>Research "
"Triangle Park</city>, <state>NC</state><postcode>27709</"
"postcode><country>USA</country> </address>"
msgstr ""
"<address> <street>1801 Varsity Drive</street> <city>Raleigh</city>, <state>NC</"
"state><postcode>27606-2072</postcode><country>USA</country> <phone>Phone: +1 "
"919 754 3700</phone> <phone>Phone: 888 733 4281</phone> <fax>Fax: +1 919 754 "
"3701</fax> <pob>PO Box 13588</pob><city>Research Triangle Park</city>, "
"<state>NC</state><postcode>27709</postcode><country>USA</country> </address>"
#. Tag: para
#, fuzzy, no-c-format
msgid ""
"Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. "
"This copyrighted material is made available to anyone wishing to use, "
"modify, copy, or redistribute it subject to the terms and conditions of the "
"GNU <ulink url=\"http://www.gnu.org/licenses/lgpl-2.1.html\">Lesser General "
"Public License</ulink>, as published by the Free Software Foundation."
msgstr ""
"Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. "
"This copyrighted material is made available to anyone wishing to use, "
"modify, copy, or redistribute it subject to the terms and conditions of the "
"GNU <ulink url=\"http://www.gnu.org/licenses/lgpl-2.1.html\">Lesser General "
"Public License</ulink>, as published by the Free Software Foundation."
#, no-c-format
msgid "<address> <street>1801 Varsity Drive</street> <city>Raleigh</city>, <state>NC</state><postcode>27606-2072</postcode><country>USA</country> <phone>Phone: +1 919 754 3700</phone> <phone>Phone: 888 733 4281</phone> <fax>Fax: +1 919 754 3701</fax> <pob>PO Box 13588</pob><city>Research Triangle Park</city>, <state>NC</state><postcode>27709</postcode><country>USA</country> </address>"
msgstr "<address> <street>1801 Varsity Drive</street> <city>Raleigh</city>, <state>NC</state><postcode>27606-2072</postcode><country>USA</country> <phone>Phone: +1 919 754 3700</phone> <phone>Phone: 888 733 4281</phone> <fax>Fax: +1 919 754 3701</fax> <pob>PO Box 13588</pob><city>Research Triangle Park</city>, <state>NC</state><postcode>27709</postcode><country>USA</country> </address> "
#. Tag: para
#, no-c-format
msgid ""
"Red Hat and the Red Hat \"Shadow Man\" logo are registered trademarks of Red "
"Hat, Inc. in the United States and other countries."
msgstr ""
"Red Hat and the Red Hat \"Shadow Man\" logo are registered trademarks of Red "
"Hat, Inc. in the United States and other countries."
msgid "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This copyrighted material is made available to anyone wishing to use, modify, copy, or redistribute it subject to the terms and conditions of the GNU <ulink url=\"http://www.gnu.org/licenses/lgpl-2.1.html\">Lesser General Public License</ulink>, as published by the Free Software Foundation."
msgstr "Copyright <trademark class=\"copyright\"></trademark> 2007 by Red Hat, Inc. This copyrighted material is made available to anyone wishing to use, modify, copy, or redistribute it subject to the terms and conditions of the GNU <ulink url=\"http://www.gnu.org/licenses/lgpl-2.1.html\">Lesser General Public License</ulink>, as published by the Free Software Foundation."
#. Tag: para
#, no-c-format
msgid ""
"All other trademarks referenced herein are the property of their respective "
"owners."
msgstr ""
"All other trademarks referenced herein are the property of their respective "
"owners."
msgid "Red Hat and the Red Hat \"Shadow Man\" logo are registered trademarks of Red Hat, Inc. in the United States and other countries."
msgstr "Red Hat and the Red Hat \"Shadow Man\" logo are registered trademarks of Red Hat, Inc. in the United States and other countries."
#. Tag: para
#, no-c-format
msgid "All other trademarks referenced herein are the property of their respective owners."
msgstr "All other trademarks referenced herein are the property of their respective owners."
#. Tag: para
#, no-c-format